BST——C++

BST树，是指左子树上所有节点都小于双亲结点，右子树上所有节点都大于双亲结点的二叉树，BST树又称为二叉排序树和二叉搜索树，理想状态下真的很不错，如果不是频繁的对树进行增删其实哈、还好，嘻嘻，就怕你改成了斜树，那样就是废品。怎么说呢，这些搜索树，都是为了模仿二分查找的，好好学习吧少年。

#include<iostream>

/*
BST的类写好了，增删改查，emmm不难，但是发现书上给的代码有问题，大话数据结构324页，4-11行。
错的离谱，感觉就像开玩笑，可能是我看错了，我没按照书上写。
*/


using  namespace  std;

typedef struct  BiTNode
{
    int data;
    BiTNode * lchild, *rchild;
}BiTNode, *BiTree;

class BSTree
{
public:
    BSTree()//提供三种构造函数
    {
        root = NULL;
    }
    BSTree(int key)
    {
        root = NULL;
        Insert(key);
    }
    BSTree(int *arr,int len)
    {
        root = NULL;
        for(int i = 0;i < len;++i)
        {
            Insert(arr[i]);
        }
    }

    bool  Delete(int key)//删除某个给定值
    {
        BiTree p =NULL;
        if(Search(key,p))
        {
            Delete_son(p);
            return true;
        }
        return false;
    }

    void Show()//打印
    {
        OrderTraverse(root);
        cout<<endl;
    }

    bool  Search(int key,BiTree & p)//查找，找到返回1，p接收结点指针，没找到返回0，p接收查找的最后一步的结点
    {
        BiTree f = NULL;
        return SearchBST_son(root,key,f,p);
    }

    bool Insert(int key)//插入，找得到就不插入
    {
        BiTree p =NULL;
        if(!Search(key,p))
        {
            BiTNode * s = new BiTNode();
            s->data = key;
            s->lchild = s->rchild =NULL;
            if(!p)
            {
                root = s;
            }
            else if(key > (p->data))
            {
                p->rchild = s;
            }
            else
            {
                p->lchild = s;
            }
            return true;
        }
        return false;
    }

    ~BSTree()//析构，采取后序遍历的方式来进行析构
    {
        PostOrderTraverse_del(root);//后序遍历_del
        root = NULL;
    }

private:
    void Delete_son(BiTree &p)//删除函数的子函数
    {
        BiTree q,s;
        if(p->lchild == NULL)//没有左孩子，采取拷贝右孩子的内容，删除右孩子，类似于，剑指里面单链表结点的O（1）删除
        {
           q = p->rchild;
           *p = *(p->rchild);
           free(q);
        }
        else if(p->rchild == NULL)//同理
        {
           q = p->lchild;
           *p = *(p->lchild);
           free(q);
        }
        else//一时半会说不清楚，自己看看书。
        {
            q = p;
            s = p -> lchild;
            while(s->rchild)
            {
                q = s;
                s = s ->rchild;
            }
            p -> data = s ->data;
            if(q == p)
            {
                q -> lchild = s -> lchild;
            }
            else 
            {
                q -> rchild = s -> lchild;
            }
            delete s;
        }
    }

    bool SearchBST_son(BiTree T,int key,BiTree f,BiTree &p)//查找函数子函数
    {
        if(!T)
        {
            p = f;
            return false;
        }
        else if(key == T->data)
        {
            p = T;
            return true;
        }
        else if(key < T->data)
        {
            return SearchBST_son(T->rchild,key,T,p);
        }
        else
        {
            return SearchBST_son(T->rchild,key,T,p);
        }
    }

    void OrderTraverse(BiTree T) 
    {
        if(!T)return ;
        OrderTraverse(T->lchild);
        cout<<T->data<<"->";
        OrderTraverse(T->rchild);
    }

    void PostOrderTraverse_del(BiTree T)//后序遍历_del
    {
        if(!T)return ;  
        PostOrderTraverse_del(T->lchild);
        PostOrderTraverse_del(T->rchild);
        delete T;
    }

    BiTree root;
};


int  main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    BSTree  bst(arr,10);
    bst.Show();
    bst.~BSTree();
    bst.Show();
}