二叉搜索树的实现 C++

#include <iostream>
using namespace std;
typedef struct BSTNode{int data;struct BSTNode *lchild,*rchild;}BSTNode;
class BSTree
{//binary search tree
public:
    explicit BSTree();
    int add(int data);
    int del(int data);
    void inOrder();
private:
    void findParent(BSTNode* &parent,int &found,int data);
    void findForDel(BSTNode* &parent,BSTNode* &node,int &found,int data);
    void traverse(BSTNode* &root);
    BSTNode *root;
};
BSTree::BSTree()
{
    root = NULL;
}
void BSTree::inOrder()
{
    traverse(root);
}
int BSTree::add(int data)
{//return -1 to indicate data already added
    BSTNode* p = NULL;
    int found;
    BSTNode* node = new BSTNode;
    if(!node)
    {
        cout<<"can't alloc memory"<<endl;
        return -1;
    }
    node->data = data;
    node->lchild = node->rchild = NULL;
    findParent(p,found,data);
    if(found)
        return -1;
    if(!p)
    {
        root = node;
    }
    else
    {
        if(p->data > data)
        {
            p->lchild = node;
            cout<<"add to "<<p->data<<"left"<<endl;
        }
        else
        {
            p->rchild = node;
            cout<<"add to "<<p->data<<"right"<<endl;
        }
    }
    return 0;
}
int BSTree::del(int data)
{//return -1 to indicate can't find data
    BSTNode *parent = NULL;
    BSTNode *node = NULL;
    int found;
    findForDel(parent,node,found,data);
    if(!found)
        return -1;
    if(!node->lchild && !node->rchild)
    {
        if(!parent)
            root = NULL;
        else if(parent->data > data)
            parent->lchild = NULL;
        else
            parent->rchild = NULL;
        delete node;
        return 0;
    }
    if(!node->lchild && node->rchild)
    {
        if(!parent)
            root = node->rchild;
        else if(parent->data > data)
            parent->lchild = node->rchild;
        else
            parent->rchild = node->rchild;
        delete node;
        return 0;
    }
    if(!node->rchild && node->lchild)
    {
        if(!parent)
            root = node->lchild;
        else if(parent->data > data)
            parent->lchild = node->lchild;
        else
            parent->rchild = node->lchild;
        delete node;
        return 0;
    }
    if(node->rchild && node->lchild)
    {
        BSTNode *nodeSuccParent = node;
        BSTNode *nodeSucc = node->rchild;
        while(nodeSucc->lchild)
        {
            nodeSuccParent = nodeSucc;
            nodeSucc = nodeSucc->lchild;
        }
        node->data = nodeSucc->data;
        nodeSuccParent->lchild == nodeSucc? nodeSuccParent->lchild = nodeSucc->rchild : nodeSuccParent->rchild = nodeSucc->rchild;
        delete nodeSucc;
        return 0;
    }
    return 0;
}
void BSTree::traverse(BSTNode* &root)
{
    if(!root)
        return;
    traverse(root->lchild);
    cout<<root->data<<' ';
    traverse(root->rchild);
}
void BSTree::findParent(BSTNode* &parent,int &found,int data)
{
    parent = NULL;
    BSTNode *p = root;
    found = 0;
    while(p)
    {
        if(p->data == data)
        {
            found = 1;
            return ;
        }
        if(p->data > data)
        {
            parent = p;
            p = p->lchild;
        }
        else//if you write if(p->data < data) error will arise
        {
            parent = p;
            p = p->rchild;
        }
    }
    cout<<"found:"<<found<<"parent="<<(parent?parent->data:0)<<endl;
}
void BSTree::findForDel(BSTNode* &parent,BSTNode* &node,int &found,int data)
{
    parent = NULL;
    found = 0;
    BSTNode* p = root;
    while(p)
    {
            if(p->data ==data)
            {
                node = p;
                found = 1;
                return ;
            }
            if(p->data > data)
            {
                parent = p;
                p = p->lchild;
            }
            else
            {
                parent = p;
                p = p->rchild;
            }
    }
}
int main(void)
{
    BSTree tree;
    int data[]={5,4,3,1,2,7,8,6};
    for(int i = 0;i < 8;i++)
        tree.add(data[i]);
    tree.del(5);
    tree.inOrder();
    return 0;
}