二叉查找树

 一个较完整的二叉查找树，实现如下功能

(1) 插入一个节点

(2) 删除一个节点

(3) 删除整棵树

(4) 查找一个节点

(5) 前序遍历，递归和非递归

(6) 中序遍历，递归和非递归

(7) 后序遍历，递归和非递归

(8) 查找最大的节点

(9) 查找最小的节点

(10) 查找某个节点的前驱

(11) 查找某个节点的后继

(12) 打印某一层内的节点

(13) 分层遍历二叉树，每一层内的节点占一行

struct BstNode
{
    int data;
    bool isVisisted;
    BstNode * left, * right;
    BstNode * father;
    BstNode(int _data=0, bool _isVisisted=false, BstNode * _left=NULL, BstNode * _right=NULL, BstNode * _father=NULL)
    {
        this->data = _data;
        this->isVisisted = _isVisisted;
        this->left = _left;
        this->right = _right;
        this->father = _father;
    }
};

class BinarySearchTree
{
public:
    BinarySearchTree(BstNode * _root = NULL);
    ~BinarySearchTree();
    void insertNode(int _data);
    void deleteNode(int _data);
    void destroyTree();
    bool findNode(int _data, BstNode * & pt, BstNode * & father);
    void preOrderPrint();
    void midOrderPrint();
    void postOrderPrint();
    void loopPreOrderPrint();
    void loopPreOrderPrint2();
    void loopMidOrderPrint();
    void loopPostOrderPrint();
    void loopPostOrderPrint2();
    BstNode * maximumTree(BstNode * node);
    BstNode * minimumTree(BstNode * node);
    BstNode * predecessor(BstNode * node);
    BstNode * successor(BstNode * node);
    void printNodeByLevel();
    int printNodeAtLevel(int level);
private:
    void dfsInsertNode(BstNode * pt,int data);
    void dfsDestroyTree(BstNode * & pt);
    void dfsPreOrderPrint(BstNode * pt);
    void dfsMidOrderPrint(BstNode * pt);
    void dfsPostOrderPrint(BstNode * pt);
    int dfsPrintNodeAtLevel(BstNode * root,int level);
    BstNode * root;
};

BinarySearchTree::BinarySearchTree(BstNode * _root)
{
    this->root = _root;
}

BinarySearchTree::~BinarySearchTree()
{
    destroyTree();
}

BstNode * BinarySearchTree::maximumTree(BstNode * node)
{
    if (node == NULL)
    {
        return NULL;
    }
    while(node->right != NULL)
    {
        node = node->right;
    }
    return node;
}

BstNode * BinarySearchTree::minimumTree(BstNode * node)
{
    if (node == NULL)
    {
        return NULL;
    }
    while(node->left != NULL)
    {
        node = node->left;
    }
    return node;
}

BstNode * BinarySearchTree::predecessor(BstNode * node)
{
    if (node->left != NULL)
    {
        return maximumTree(node->left);
    }
    BstNode * fatherNode = node->father;
    while(fatherNode != NULL && node==fatherNode->left)
    {
        node = fatherNode;
        fatherNode = fatherNode->father;
    }
    return fatherNode;
}

BstNode * BinarySearchTree::successor(BstNode * node)
{
    if (node->right != NULL)
    {
        return minimumTree(node->right);
    }
    BstNode * fatherNode = node->father;
    while(fatherNode != NULL && node==fatherNode->right)
    {
        node = fatherNode;
        fatherNode = fatherNode->father;
    }
    return fatherNode;
}

bool BinarySearchTree::findNode(int _data, BstNode * & pt, BstNode * & father)
{
    pt = root;
    while(pt != NULL)
    {
        if (pt->data == _data)
        {
            return true;
        }
        father = pt;
        if (_data < pt->data)
        {
            pt = pt->left;
        }
        else
        {
            pt = pt->right;
        }
    }
    return false;
}

void BinarySearchTree::insertNode(int _data)
{
    dfsInsertNode(root,_data);
}

void BinarySearchTree::dfsInsertNode(BstNode * pt,int data)
{
    if (root == NULL)
    {
        root = new BstNode(data);
        return;
    }
    if (pt == NULL)
    {
        return;
    }
    if (data < pt->data)
    {
        if (pt->left == NULL)
        {
            pt->left = new BstNode(data);
            pt->left->father = pt;
        }
        else
        {
            dfsInsertNode(pt->left,data);
        }
    }
    else
    {
        if (pt->right == NULL)
        {
            pt->right = new BstNode(data);
            pt->right->father = pt;
        }
        else
        {
            dfsInsertNode(pt->right,data);
        }
    }
}

void BinarySearchTree::deleteNode(int _data)
{
    BstNode * pt = NULL, * fathePt = NULL;
    bool flag = findNode(_data,pt,fathePt);
    if (!flag)
    {
        return;
    }
    if (pt->left==NULL && pt->right==NULL)
    {
        if (pt == root)
        {
            delete root;
            root = NULL;
        }
        else
        {
            if (pt==fathePt->left)
            {
                fathePt->left = NULL;
            }
            else
            {
                fathePt->right = NULL;
            }
            delete pt;
        }
    }
    else if(pt->left != NULL && pt->right == NULL)
    {
        if (pt == root)
        {
            BstNode * tmp = pt->left;
            delete root;
            root = tmp;
        }
        else
        {
            if (pt == fathePt->left)
            {
                fathePt->left = pt->left;
            }
            else
            {
                fathePt->right = pt->left;
            }
            delete pt;
        }
    }
    else if (pt->right != NULL && pt->left == NULL)
    {
        if (pt == root)
        {
            BstNode * tmp = pt->right;
            delete root;
            root = tmp;
        }
        else
        {
            if (pt == fathePt->left)
            {
                fathePt->left = pt->right;
            }
            else
            {
                fathePt->right = pt->right;
            }
            delete pt;
        }
    }
    else
    {
        BstNode * tpt = successor(pt);
        int tdata = tpt->data;
        BstNode * tfatherPt = tpt->father;
        if (tpt == tfatherPt->left)
        {
            tfatherPt->left = tpt->right;
        }
        else
        {
            tfatherPt->right = tpt->right;
        }
        pt->data = tdata;
        delete tpt;
    }
}

void BinarySearchTree::destroyTree()
{
    dfsDestroyTree(root);
}

void BinarySearchTree::dfsDestroyTree(BstNode * & pt)
{
    if (pt != NULL)
    {
        dfsDestroyTree(pt->left);
        dfsDestroyTree(pt->right);
        pt = NULL;
    }
}

void BinarySearchTree::preOrderPrint()
{
    dfsPreOrderPrint(root);
}

void BinarySearchTree::dfsPreOrderPrint(BstNode * pt)
{
    if (pt != NULL)
    {
        cout<<pt->data <<" ";
        dfsPreOrderPrint(pt->left);
        dfsPreOrderPrint(pt->right);
    }
}

void BinarySearchTree::midOrderPrint()
{
    dfsMidOrderPrint(root);
}

void BinarySearchTree::dfsMidOrderPrint(BstNode * pt)
{
    if (pt != NULL)
    {
        dfsMidOrderPrint(pt->left);
        cout<<pt->data <<" ";
        dfsMidOrderPrint(pt->right);
    }
}

void BinarySearchTree::postOrderPrint()
{
    dfsPostOrderPrint(root);
}

void BinarySearchTree::dfsPostOrderPrint(BstNode * pt)
{
    if (pt != NULL)
    {
        dfsPostOrderPrint(pt->left);
        dfsPostOrderPrint(pt->right);
        cout<<pt->data <<" ";
    }
}

void BinarySearchTree::loopPreOrderPrint()
{
    stack<BstNode *> stk;
    BstNode * pt = root;
    while(pt!=NULL || !stk.empty())
    {
        if (pt != NULL)
        {
            cout<<pt->data <<" ";
            stk.push(pt);
            pt = pt->left;
        }
        else
        {
            pt = stk.top();
            stk.pop();
            pt = pt->right;
        }
    }
}

void BinarySearchTree::loopPreOrderPrint2()
{
    if (root == NULL)
    {
        return;
    }
    stack<BstNode *> stk;
    stk.push(root);
    while(!stk.empty())
    {
        BstNode * top = stk.top();
        stk.pop();
        cout<<top->data <<" ";
        if (top->right != NULL)
        {
            stk.push(top->right);
        }
        if (top->left != NULL)
        {
            stk.push(top->left);
        }
    }
}

void BinarySearchTree::loopMidOrderPrint()
{
    stack<BstNode *> stk;
    BstNode * pt = root;
    while(pt!=NULL || !stk.empty())
    {
        if (pt != NULL)
        {
            stk.push(pt);
            pt = pt->left;
        }
        else
        {
            pt = stk.top();
            stk.pop();
            cout<<pt->data <<" ";
            pt = pt->right;
        }
    }
}

void BinarySearchTree::loopPostOrderPrint()
{
    stack<BstNode *> stk;
    BstNode * pt = root;
    while(pt!=NULL || !stk.empty())
    {
        if (pt != NULL)
        {
            pt->isVisisted = false;
            stk.push(pt);
            pt = pt->left;
        }
        else
        {
            pt = stk.top();
            if(pt->isVisisted)  
            {  
                cout<<pt->data<<" ";  
                stk.pop();  
                pt = NULL;  
            }  
            else  
            {  
                pt->isVisisted = true;
                pt=pt->right;  
            }  
        }
    }
}

void BinarySearchTree::loopPostOrderPrint2()
{
    stack<BstNode *> stk;
    BstNode * preNode = NULL;     //指向前一个被访问的节点
    BstNode * pt = root;        //指向当前要检查的节点
    while(pt!=NULL || !stk.empty())
    {
        while(pt != NULL)     //一直向左走直到为空
        {
            stk.push(pt);
            pt = pt->left;
        }
        pt = stk.top();
        //当前节点的右孩子如果为空或者已经被访问，则访问当前节点
        if (pt->right == NULL || pt->right==preNode)
        {
            cout<<pt->data <<" ";
            stk.pop();
            preNode = pt;
            pt = NULL;
        }
        else    //否则访问右孩子
        {
            pt = pt->right;
        }
    }
}

int BinarySearchTree::printNodeAtLevel(int level)
{
    return dfsPrintNodeAtLevel(root,level);
}

int BinarySearchTree::dfsPrintNodeAtLevel(BstNode * root,int level)
{
    if (root==NULL || level<0)
    {
        return 0;
    }
    if (level == 0)
    {
        cout<<root->data <<" ";
        return 1;
    }
    return dfsPrintNodeAtLevel(root->left,level-1)+dfsPrintNodeAtLevel(root->right,level-1);
}

void BinarySearchTree::printNodeByLevel() 
{
    if (root == NULL)
    {
        return;
    }
    vector<BstNode *> vec;
    vec.push_back(root);
    int cur = 0, last = 1;
    while(cur < vec.size())
    {
        last = vec.size();
        while(cur < last)
        {
            cout<<vec[cur]->data <<" ";
            if (vec[cur]->left != NULL)
            {
                vec.push_back(vec[cur]->left);
            }
            if (vec[cur]->right != NULL)
            {
                vec.push_back(vec[cur]->right);
            }
            cur++;
        }
        cout<<endl;
    }
}