C++生成二叉搜索树，以及数据的查找，删除和插入

一.自己定义的结构体

这个是节点的类，自己定义了一个有参构造。二叉树的左右孩子和当前节点的值。

class Node{
public:
  Node(int v) : m_value(v), m_right(nullptr), m_left(nullptr) {};
  Node* m_left;
  Node* m_right;
  int m_value;
};

下面是数的类，包括树的根节点和树的方法的声明

class Tree
{
public:
    Tree() :m_root(nullptr) {}
    void CreateTree(int* arr, int n) {
        CreateTree(arr,n,m_root);
    }
    void CreateTree(int* arr, int n, Node* root) ;
    void InsertBstValue(int v) {}
    void InsertBstValue(Node*& root, int v) ;
    void search(int v) {
    search(m_root,v);
    }   
    Node* search(Node*& root, int v) ;
    void del(int v) {
        del(m_root,v);
    }
    void del(Node*& root, int v) ;
    Node* Getmin2() {
        getmin2(m_root);
    }
    Node* getmin2(Node* root) ;
    void Getmin() {
        getmin(m_root);
    }
    Node* getmin(Node* root) ;
    Node* Getmax(){
        getmax(m_root);
    }
    Node* getmax(){};
    void postOrder() {
        posrOrder(m_root);
    }
    void postOrder(Node* m_root) ;
private:
    Node* m_root;
};

二.对于树类中的函数的实现

1.构造树的函数

    void Tree::CreateTree(int *arr,int n,Node* root){
        for(int i=0;i<n;i++){
            InsertBstValue(arr[i]);
        }
    }

这个函数会接受数组和数组大小，然后通过多传入的根节点来初始化一棵树。每次插入一个数组元素。

2.对于每个数据的插入

    void Tree::InsertBstValue(Node* &root,int v){
        if(root== nullptr){
            root=new Node(v);
        }else {
            if (v < root->m_value) {
                InsertBstValue(root->m_left, v);
            } else {
                InsertBstValue(root->m_right, v);
            }
        }
    }

当我们需要插入的时候，我们需要判断当前元素应该所处的位置。到达位置之后，新建节点后插入。

3.对于数据的查找

    Node* Tree::search(Node*& root,int v){
        if(root!= nullptr){
            if(root->m_value<v){
                search(root->m_right,v);
            }else if(root->m_value>v){
                search(root->m_left,v);
            }else{
                return root;
            }
        }
        return nullptr;
    }

因为我们是二叉排序树，我们可以通过类似二分查找的方式，每次遍历当前根节点所在的做或者右子树。找不到的话，返回空。

3.对于数据的删除，我们需要调用find函数。并且传的必须是引用

    void Tree::del(int v){
        Node* temp = search(m_root,v);
        if(temp== nullptr) {
            printf("error");
            return;
        }
        del(temp,v);
    }
    void Tree::del(Node* &root,int v){
        if(root!= nullptr){
            if(root->m_left!= nullptr&&root->m_right!= nullptr){
                Node* temp=root->m_right;
                while(temp->m_left){
                    temp=temp->m_left;
                }
                m_root->m_value=temp->m_value;
                del(temp,0);
            }else{
                Node* temp=root;
                if(root->m_left== nullptr){
                    root=root->m_right;
                }else{
                    root=root->m_left;
                }
            }
        }
    }

4.中序遍历后就是一个从小到大的排序

    void Tree::postOrder(){
        postOrder(m_root);
    }
    void Tree::postOrder(Node* m_root){
        if(m_root!= nullptr) {
            postOrder(m_root->m_left);
            cout << m_root->m_value<<" ";
            postOrder(m_root->m_right);
        }
    }