二叉搜索树的搜索和插入与删除算法优化

代码是根据之前的二叉树模板修改来的，删去了非递归遍历，加入二叉搜索树的搜索、插入和删除，实现方法在73~153行

#include<iostream>
#include<stack>
#include<queue>
using namespace std;
template <class T> class BinaryTree;
template <class T>
class BinaryTreeNode
{
    friend class BinaryTree<T>;
private:
    T data; //二叉树数据域
    BinaryTreeNode *leftchild; //左孩子指针
    BinaryTreeNode *rightchild; //右孩子指针
public:
    BinaryTreeNode(){leftchild=rightchild=NULL;}
    BinaryTreeNode(const T elem)
    {
        data=elem;
        leftchild=rightchild=NULL;
    }
    BinaryTreeNode(const T elem,BinaryTreeNode<T> *l,BinaryTreeNode<T> *r)
    {
        data=elem;
        leftchild=l;
        rightchild=r;
    }
    BinaryTreeNode<T> * left() const{return leftchild;}
    BinaryTreeNode<T> * right() const{return rightchild;}
    void setLeft(BinaryTreeNode *l){leftchild=l;}
    void setRight(BinaryTreeNode *r){rightchild=r;}
    void setValue(const T value){data=value;}
    T Value(){return data;}
    bool isLeaf()
    {
        if(leftchild==NULL&&rightchild==NULL)
            return true;
        else
            return false;
    }
    BinaryTreeNode<T>& operator = (const BinaryTreeNode<T> &Node)
    {
        cout << "=" ;
        data=Node.data;
        leftchild=Node.leftchild;
        rightchild=Node.leftchild;
        return *this;
    }
};
template <class T>
class BinaryTree
{
private:
    BinaryTreeNode<T> *root;
    void setRoot(BinaryTreeNode<T> *r){root=r;}
public:
    BinaryTree(){root=NULL;}
    bool isEmpty() const
    {
        if(root==NULL)
            return true;
        return false;
    };
    BinaryTreeNode<T> * Root(){return root;}
    BinaryTreeNode<T> * Parent(BinaryTreeNode<T> *current);
    BinaryTreeNode<T> * LeftSibling(BinaryTreeNode<T> *current);
    BinaryTreeNode<T> * RightSibling(BinaryTreeNode<T> *current);
    void CreatTree(const T &info,BinaryTree<T> &left,BinaryTree<T> &right);
    void PreOrder(BinaryTreeNode<T> *root);
    void InOrder(BinaryTreeNode<T> *root);
    void PostOrder(BinaryTreeNode<T> *root);
    void LevelOrder(BinaryTreeNode<T> *root);
    void deleteBinaryTree(BinaryTreeNode<T> *root);
    void InsertNode(BinaryTreeNode<T> *root,BinaryTreeNode<T> *newpointer)
    {
        BinaryTreeNode<T> *pointer=NULL;
        if(root==NULL)//根节点为空,直接插入
        {
            setRoot(newpointer);
            return;
        }
        else pointer=root;
        while(pointer!=NULL)
        {
            if(newpointer->Value()==pointer->Value())
                return;
            else if((newpointer->Value())<(pointer->Value()))
            {
                if(pointer->left()==NULL)
                {
                    pointer->setLeft(newpointer);
                    return;
                }
                else
                    pointer=pointer->left();
            }
            else
            {
                if(pointer->right()==NULL)
                {
                    pointer->setRight(newpointer);
                    return;
                }
                else pointer=pointer->right();
            }
        }
    }
    void DeleteNodeEx(BinaryTreeNode<T> *pointer)
    {
        //优化的搜索二叉树删除算法
        //若待删结点有左子树，则寻找左子树中最大的结点，将此结点的左子树挂接到其父节点的右子树上
        //将待删结点替换成左子树中最大的结点，删除待删结点
        if(pointer==NULL)return;
        BinaryTreeNode<T> *temppointer;
        BinaryTreeNode<T> *tempparent=NULL;
        BinaryTreeNode<T> *parent=Parent(pointer);
        if(pointer->left()==NULL)
            temppointer=pointer->right();
        else{
            temppointer=pointer->left();
            while(temppointer->right()!=NULL)
            {
                tempparent=temppointer;
                temppointer=temppointer->right();
            }
            if(tempparent==NULL)
                pointer->setLeft(temppointer->left());
            else tempparent->setRight(temppointer->left());
            temppointer->setLeft(pointer->left());
            temppointer->setRight(pointer->right());
        }
        if(parent==NULL)root=temppointer;
        else if((parent->left())==pointer)parent->setLeft(temppointer);
        else parent->setRight(temppointer);
        delete pointer;
        pointer=NULL;
        return;
    }
    BinaryTreeNode<T> * Find(const T value)
    {
        if(root==NULL)return NULL;
        BinaryTreeNode<T> *p;
        p=root;
        while(p!=NULL&&(p->Value())!=value)
        {
            if((p->Value())>value)
                p=p->left();
            else p=p->right();
        }
        if((p->Value())==value)return p;
        cout << "non-exist" <<endl;
        return NULL;
    }
};
template <class T>
class StackElem{
public:
    BinaryTreeNode<T> *pointer;
    int tag;
};
template <class T>
BinaryTreeNode<T> * BinaryTree<T>::Parent(BinaryTreeNode<T> *current) //返回当前结点的父结点
{
    using std::stack;
    stack<BinaryTreeNode<T> *> aStack; //使用栈存放未访问右子树的结点
    BinaryTreeNode<T> *pointer=root;
    if(root!=NULL&&current!=NULL)
    {
        while(!aStack.empty()||pointer!=NULL)
        {
            if(pointer!=NULL)
            {
                if(current==pointer->left()||current==pointer->right())
                    return pointer;
                aStack.push(pointer);
                pointer=pointer->left();
            }
            else
            {
                pointer=aStack.top();
                aStack.pop();
                pointer=pointer->right();
            }
        }
        return NULL;
    }
    else
        return NULL;
}
template <class T>
BinaryTreeNode<T> * BinaryTree<T>::LeftSibling(BinaryTreeNode<T> *current) //返回当前节点左兄弟
{
    using std::stack;
    stack<BinaryTreeNode<T> *>aStack;
    BinaryTreeNode<T> *pointer=root;
    if(root!=NULL&&current!=NULL)
    {
        while(!aStack.empty()||pointer!=NULL)
        {
            if(pointer!=NULL)
            {
                if(current==pointer->right()&&(pointer->left())!=NULL)
                    return pointer->left();
                aStack.push(pointer);
                aStack.pop();
                pointer=pointer->left();
            }
            else
            {
                pointer=aStack.top();
                aStack.pop();
                pointer=pointer->right();
            }
        }
        return NULL;
    }
    else
        return NULL;
}
template <class T>
BinaryTreeNode<T> * BinaryTree<T>::RightSibling(BinaryTreeNode<T> *current) //返回当前节点右兄弟
{
    using std::stack;
    stack<BinaryTreeNode<T> *>aStack;
    BinaryTreeNode<T> *pointer=root;
    if(root!=NULL&&current!=NULL)
    {
        while(!aStack.empty()||pointer!=NULL)
        {
            if(pointer!=NULL)
            {
                if(current==pointer->left()&&(pointer->right())!=NULL)
                    return pointer->right();
                aStack.push(pointer);
                aStack.pop();
                pointer=pointer->left();
            }
            else
            {
                pointer=aStack.top();
                aStack.pop();
                pointer=pointer->right();
            }
        }
        return NULL;
    }
    else
        return NULL;
}
template <class T>
void BinaryTree<T>::CreatTree(const T &info,BinaryTree<T> &left,BinaryTree<T> &right) //创建树
{
    root=new BinaryTreeNode<T>(info,left.root,right.root);
    left.root=right.root=NULL;
}
template <class T>
void BinaryTree<T>::PreOrder(BinaryTreeNode<T> *root) //先序遍历
{
    if(root!=NULL)
        visit(root);
    else
        return;
    PreOrder(root->left());
    PreOrder(root->right());
}
template <class T>
void BinaryTree<T>::InOrder(BinaryTreeNode<T> *root) //中序遍历
{
    if(root==NULL)
        return;
    InOrder(root->left());
    visit(root);
    InOrder(root->right());
}
template <class T>
void BinaryTree<T>::PostOrder(BinaryTreeNode<T> *root) //后序遍历
{
    if(root==NULL)
        return;
    PostOrder(root->left());
    PostOrder(root->right());
    visit(root);
}
template <class T>
void BinaryTree<T>::LevelOrder(BinaryTreeNode<T> *root) //层次遍历
{
    using std::queue;
    queue<BinaryTreeNode<T> *> aQueue;
    BinaryTreeNode<T> *p=root,*q;
    aQueue.push(p);
    while(!aQueue.empty())
    {
        p=aQueue.front();
        aQueue.pop();
        visit(p);
        q=p;
        if((p->left())!=NULL)
        {
            q=p->left();
            aQueue.push(q);
        }
        if((p->right())!=NULL)
        {
            q=p->right();
            aQueue.push(q);
        }
    }
}
template <class T>
void BinaryTree<T>::deleteBinaryTree(BinaryTreeNode<T> *root) //删除以root为根节点的树
{
    if(root==NULL)return;
    deleteBinaryTree(root->left());
    deleteBinaryTree(root->right());
    delete root;
    root=NULL;
}

void visit(BinaryTreeNode<int> *Root) //访问结点元素
{
    if(Root!=NULL)
        cout << Root->Value() <<" ";
}
int main()
{
    BinaryTreeNode<int> *p;
    BinaryTreeNode<int> e(10);
    BinaryTree<int> a,b,c;
    int n,s,l=1;
    cout << "Enter the number of node" <<endl;
    while(cin>>n)
    {
        for(int i=0;i<n;i++)
        {
            cin>>s;
            p=new BinaryTreeNode<int>(s);
            a.InsertNode(a.Root(),p);
        }
        a.InOrder(a.Root());
        cout <<endl;
        a.PreOrder(a.Root());
        cout <<endl;
        a.LevelOrder(a.Root());
        cout <<endl;
        cin>>l;
        cout << "Enter the number of delete node" <<endl;
        for(int i=0;i<l;i++)
        {
            cin>>s;
            p=a.Find(s);
            if(p!=NULL)
            {
                a.DeleteNodeEx(p);
                a.InOrder(a.Root());
                cout << endl;
                a.PreOrder(a.Root());
                cout <<endl;
                a.LevelOrder(a.Root());
                cout <<endl;
            }
        }
    }
    return 0;
}