BST

#include <IOSTREAM>
#include <QUEUE>
using namespace std;

//结点的结构体
//内涵三个参数，关键字Key，左孩子指针，右孩子指针
typedef struct _NODE_
{
    int Key;
    _NODE_* pLeft;
    _NODE_* pRight;
}Node,*pNode;

//中序遍历
void InOrderTraves(pNode T);


//层状遍历
void LevelTraves(pNode T);

//搜索结点
bool SearchNode(pNode T, int Key, pNode& f, pNode& p);

//插入结点
bool InsertNode(pNode& T,int Key);

//删除结点
void DeleteNode(pNode& T,int Key);

//销毁树
void DestroyTree(pNode& T);

//测试函数
int main()
{
    pNode BST = NULL;
    int Key = 0;
    cout<<"Create a BST: ";
    cin>>Key;
    while (Key != -1)
    {
        InsertNode(BST,Key);
        cin>>Key;
    }

    InOrderTraves(BST);
    cout<<endl;
    LevelTraves(BST);
    cout<<endl;

    DestroyTree(BST);
    return 0;
}

void InOrderTraves(pNode T)
{
    if (T != NULL)
    {
        InOrderTraves(T->pLeft);
        cout<<T->Key<<" ";
        InOrderTraves(T->pRight);
    }
}

//使用STL 的 queue队列
void LevelTraves(pNode T)
{
    if (T == NULL)
    {
        return;
    }

    pNode p = T;

    queue<pNode> Que;
    Que.push(p);

    while (!Que.empty())
    {
        p = Que.front();
        Que.pop();
        cout<<p->Key<<" ";

        if (p->pLeft != NULL)
        {
            Que.push(p->pLeft);
        }
        if (p->pRight != NULL)
        {
            Que.push(p->pRight);
        }
    }

}


// 查找函数
// 参数：
// 树根T， 待查找的关键字Key， 
// 指针f（用于存放找到结点的父节点）
// 指针p（用于存放找到结点）
bool SearchNode(pNode T, int Key, pNode& f, pNode& p)
{
    p = T;
    if (p == NULL)
    {
        return false;
    }
    while (p!=NULL)
    {
        if (p->Key == Key)
        {
            return true;
        }
        if (p->Key > Key)
        {
            f = p;
            p = p->pLeft;
        }
        if (p->Key < Key)
        {
            f = p;
            p = p->pRight;
        }
    }

    return false;
}


bool InsertNode(pNode& T,int Key)
{

    //如果根结点不存在，动态申请内存空间
    if (T == NULL)
    {
        T = (pNode)malloc(sizeof(Node));

        T->Key = Key;
        T->pLeft = T->pRight = NULL;

        return true;
    }
    //在保持BST的性质的情况下进行插入
    else
    {
        if (T->Key == Key)
        {
            cout<<"Error"<<endl;
            return false;
        }
        if (T->Key > Key)
        {
            InsertNode(T->pLeft,Key);
        }
        else
        {
            InsertNode(T->pRight,Key);
        }
    }

    return false;
}


//有四种情况

/*
*    情况一： 待删结点为叶子结点（无左孩子也无又孩子）
*    直接将其父节点的左（或者右）孩子的值赋为空
*    
*    情况二： 待删结点只有左子树
*    将其父节点的左子树赋为待删结点的左子树
*
*    情况三： 待删结点只有右子树
*    将其父节点的右子树赋为待删结点的右子树
*
*    情况四： 待删结点既有右子树，右有左子树
*    找到待删结点的前驱结点，替换待删结点。
*/
void DeleteNode(pNode& T,int Key)
{

    pNode p = NULL;
    pNode q = NULL;
    pNode s = NULL;
    pNode f = NULL;

    if(SearchNode(T,Key,f,p))
    {
        if (p->pLeft && p->pRight)
        {
            q = p;
            //找到p的直接前驱
            s = s->pLeft;
            while (s->pRight != NULL)
            {
                q = s;
                s = s->pRight;
            }

            //将值和直接前驱调换
            p->Key = s->Key;

            //这种情况是一般情况，q 和 p不相等
            if (q != p)
            {
                q->pRight = s->pLeft;
            }
            //特殊情况
            else
            {
                q->pLeft =s->pLeft;
            }
        }
        else if(p->pLeft == NULL && p->pRight == NULL)
        {
            if (f->pRight == p)
            {
                f->pRight = NULL;
            }
            else
            {
                f->pLeft = NULL;
            }
        }
        else if (p->pLeft != NULL && p->pRight == NULL)
        {
            f->pLeft = p->pLeft;
        }
        else
        {
            f->pRight = p->pRight;
        }
    }

}

void DestroyTree(pNode& T)
{
    if (T != NULL)
    {
        if (T->pLeft != NULL)
        {
            DestroyTree(T->pLeft);
        }
        if (T->pRight != NULL)
        {
            DestroyTree(T->pRight);
        }

        free(T);
    }
}