二叉排序树实现（C++）

最近要找工作了，着手实现了二叉排序树，这里主要说一下我的主要收获：加深了对指针的理解，尤其是二重指针。如果你还没发现二重指针的奥妙，说明你还没懂C++，当然，你懂了也可能没懂。下面是我的源码：

#include<memory>
#include<iostream>
using namespace std;
class bitreenode
{
public:
    int data;
    bitreenode * lchild;
    bitreenode * rchild;
    bitreenode(){ lchild = rchild = nullptr; }
};
class biTree
{
public:
    biTree();
    bool search(bitreenode * tree, int key, bitreenode *parent, bitreenode **p);
    bool deletNode(bitreenode **node); 
    bool delet(bitreenode ** tree, int key);
    bool insert(bitreenode ** tree, int key);
    bool createtree(bitreenode** tree);
    bitreenode *root;
};

biTree::biTree()
{
    root=nullptr;
}

bool biTree::search(bitreenode * tree, int key, bitreenode *parent, bitreenode **p)//需要重写的指针用二重指针，p用于记录结果
{
    if (tree==nullptr)
    {
        *p = parent;
        return false;
    }
    else if (tree->data==key)
    {
        *p = tree;
        return true;
    }
    else if (tree->data > key)
    {
        return search(tree->lchild, key, tree, p);
    }
    else
    {
        return search(tree->rchild, key, tree, p);
    }
}

bool biTree::insert(bitreenode ** tree, int key)
{
    bitreenode *p=nullptr,*temNode=nullptr;
    temNode = new bitreenode();
    temNode->data = key;
    if (!search(*tree, key, nullptr,&p))
    {
        if (!p)
        {
            (*tree) = temNode;
        }
        else if (p->data < key)
        {
            p->rchild = temNode;
        }
        else           //p->data 和key不可能相等
            p->lchild = temNode;
        return true;
    }
    else
        return false;//有匹配记录，不插入
}

bool biTree::createtree(bitreenode **tree)
{
    int arr[10] = {4,2,3,6,5,1,7,8,9,10}; 
    int i = 0;
    for (auto &i:arr)
    {
        insert(tree,i);
    }
    return true;
}

//节点删除有三种情况：1、叶子节点，2、左子树或右子树为空，3、左右子树均不为空
bool biTree::deletNode(bitreenode **node)
{
    bitreenode *temNode = nullptr, *backnode/*欲删除节点的后继*/= nullptr;
    //情况1包含于情况2
    if (!(*node)->lchild)//左子树为空
    {

        temNode = *node;
        *node = (*node)->rchild;//重接右子树
        delete temNode;

    }
    else if (!(*node)->rchild)
    {
        temNode = *node;
        *node = (*node)->lchild;
        delete temNode;
    }
    else
    {
        backnode = (*node)->rchild;
        temNode = *node;//表示后继的双亲
        while (backnode->lchild)
        {
            temNode = backnode;
            backnode = backnode->lchild;
        }//找到删除节点的前驱和前驱的双亲

        if (backnode==(*node)->rchild)//后继节点是右孩子
        {
            (*node)->data = backnode->data;
            temNode->rchild = backnode->rchild;
            delete backnode;
        }
        else//后继节点位于右孩子的左分支
        {
            (*node)->data = backnode->data;
            temNode->lchild = backnode->rchild;
            delete backnode;
        }
    }
    return true;
}


bool  biTree::delet(bitreenode ** tree, int key)//用后继替换删除节点
{
    if (!(*tree))
    {
        return false;
    }
    else
    {
        if ((*tree)->data == key)
            return deletNode(tree);
        else if ((*tree)->data < key)
            return delet(&(*tree)->rchild, key);
        else
            return delet(&(*tree)->lchild, key);
    }
    return true;
}

int main()
{
    int i = 0;
    biTree tree;
    bitreenode *p;
    tree.createtree(&(tree.root));
    tree.delet(&(tree.root), 4);
    cout << tree.root->data;
    return 0;
}