二叉搜索树BST实现(c++语言)

#include <unistd.h>
#include <iostream>
#include <stdlib.h>
#include <vector>

using namespace std;

struct Node{
    int val;
    int hei;
    Node *left;
    Node *right;
    Node(int v){
        val=v;
        hei=0;
        left=NULL;
        right=NULL;
    };
};

class BST{
public:
    BST(vector<int> &arr){
        root=NULL;
        this->arr=arr;
        flags=0;
    };
    ~BST(){
        delete root;
        root=NULL;
    };

   void  preOrdr(Node *rt, vector<int> &arr){
        if(rt==NULL)return;
        arr.push_back(rt->val);
        preOrdr(rt->left, arr);
        preOrdr(rt->right, arr);
    }

    void  InOrdr(Node *rt, vector<int> &arr){
        if(rt==NULL)return;
        InOrdr(rt->left, arr);
        arr.push_back(rt->val);
        InOrdr(rt->right, arr);
    }

    void  PostOrdr(Node *rt, vector<int> &arr){
        if(rt==NULL)return;
        PostOrdr(rt->left, arr);
        PostOrdr(rt->right, arr);
        arr.push_back(rt->val);
    }

    void recurInsert(Node * rt,int val){
       if(val<rt->val){
           //如果左子树为空，则插入，否则递归
           if(rt->left==NULL){
               rt->left=new Node(val);
           }else{
               recurInsert(rt->left,val);
           }
       }
       else if( val>rt->val)
       {
           //如果右子树为空，则插入，否则递归
           if(rt->right==NULL){
               rt->right=new Node(val);
           }else{
               recurInsert(rt->right,val);
           }
       }
       return;
   }

    void insert(int val)
    {
       if(root==NULL){
           root=new Node(val);
           return;
       }
       recurInsert(root,val);
    }

    void buildBST(){
       for(int i=0;i<arr.size();i++)
       {
           insert(arr[i]);
       }
    }

    void findPath(Node * rt,int x, vector<Node *> &path){
       if(rt->val==x){
           path.push_back(rt);
           return;
       }
       path.push_back(rt);
       if(x<rt->val){
           findPath(rt->left,x, path);
       }else{
           findPath(rt->right,x, path);
       }
   }


   int predecessor(Node * rt)
   {
       while(rt->right!=NULL){
           rt=rt->right;
       }
       return rt->val;

   }


    int successor(Node * rt){
        while(rt->left!=NULL){
            rt=rt->left;
        }
        return rt->val;
   }


    void del(int val)
    {
        //找到当前的路径
        vector<Node *> path;
        findPath(root,val, path);
        //如果当前节点没有子树
        auto cur=path.back();
        if(cur->left==NULL && cur->right==NULL){
            //判断当前删除的节点是否是根结点
            if(path.size()==1){
                root=NULL;
            }
            else{
                auto pre=path[path.size()-2];
                //判断当前节点在父节点的那个方向上
                if(pre->left!=NULL && pre->left->val==cur->val){
                    //在左
                    pre->left=NULL;
                }else{
                    pre->right=NULL;
                }
            }
            return;
        }else if(cur->left!=NULL && cur->right==NULL ){
            //判断当前删除的节点是否是根结点
            if(path.size()==1){
                root=cur->left;
                delete cur;
                cur=NULL;
            }else{
                auto pre=path[path.size()-2];
                //判断当前节点在父节点的那个方向上
                if(pre->left!=NULL && pre->left->val==cur->val){
                    //在左
                    pre->left=cur->left;
                }
                else{
                    pre->right=cur->left;
                }
                delete cur;
                cur=NULL;
            }
            return;
        }else if(cur->left==NULL && cur->right!=NULL ){
            if(path.size()==1){
                root=cur->right;
                delete cur;
                cur=NULL;
            }else{
                auto pre=path[path.size()-2];
                //判断当前节点在父节点的那个方向上
                if(pre->left!=NULL && pre->left->val==cur->val){
                    //在左
                    pre->left=cur->right;
                }
                else{
                    pre->right=cur->right;
                }
                delete cur;
                cur=NULL;
            }
            return;
        }

        //查找直接前驱
        if(flags==0)
        {
            int pre= predecessor(cur->left);
            //一定先删除再赋值
            del(pre);
            cur->val=pre;
        }else{
            int next= successor(cur->right);
            del(next);
            cur->val=next;
        }
        return;
    }


    vector<int> getPreorder(){
        vector<int> res;
        preOrdr(root,res);
       return res;
   }


private:
    Node *root;
    vector<int> arr;
    int flags;//0-pre

};

ostream &operator<<(ostream &out,vector<int> &arr)
{
    for(int i=0;i<arr.size();i++)
    {
        cout<<arr[i]<<",";
    }
    cout<<endl;
}



int main(){

    vector<int> arr={6,4,10,1,5,9};
    BST *p=new BST(arr);
    p->buildBST();
    auto res=p->getPreorder();
    cout<<res<<endl;
    p->del(4);
    res=p->getPreorder();
    cout<<res<<endl;

    pause();
    return 0;
}