从BinarySearchTree到RedBlackTree之BST

起源

起源是看侯捷大佬的STL源码解读+Linux内核设计的时候都遇到了红黑树的问题，想必其作为强大的底层支撑的存在是很重要的。
但基于那天翻阅知乎被某条牛逼评论刺激到后，才有了循序渐进完成全部的想法。

Binary_Search_Tree

二叉搜索树，二叉排序树等等名称。
其核心就是左子树的key<根的key<右子树的key，在其操作中属delete操作最为复杂。
其包含的一些结论，我们的二叉搜索树按照树的中序遍历来就是一个有序的升序序列，有兴趣的话可以去做一些比如 (根据某两个遍历顺序还原一棵树的题目)。
其优点：相对于线性表，比如vector，array等，查找元素的时间复杂度为O(n/2)，因为最坏要搜全部n个，最好只要搜第一个，平均一下就好了，这棵树的搜索平均复杂度是O(logn)。
其缺点：如果我们对一个有序序列进行建树，其会退化为一根链表，那就和线性表是一样的了。正因如此有我们后面更高级的AVL Tree和Red Black Tree！

代码

这个因为是数据结构课的内容，我主要有对delete进行详细解释，其余的也不用多讲了。
而且大家上LeetCode，没人闲到让你来实现构建、插入、删除甚至查找、遍历这种弱智的操作，都是给你一棵建好的树让你在其上面进行操作的。
还有一点，我这里面都没有用递归，递归显然是一种更简练的方法，但把递归改为非递归可以帮助你更好的理解整个程序的过程，而且不容易搞混一些。
直接附上代码：

#include <iostream>
#include <vector>
using namespace std;

template<typename T>
struct TreeNode{
    T data;
    TreeNode *parent;
    TreeNode *left;
    TreeNode *right;
    TreeNode(T num, TreeNode* l = NULL, TreeNode* r = NULL):data(num), left(l), right(r){}
};

template<typename T>
class BSTree{
    private:
        TreeNode<T> *root;
    public:
        BSTree() { root = NULL; }
        TreeNode<T> *getroot() { return root; }
        bool createTree(vector<T> vec);
        bool insert(T data);
        bool deletenode(T data);
        bool search(T data);
};

template<typename T>
bool BSTree<T>::createTree(vector<T> vec){
    int num = 0;
    bool flag = true;
    if(root == NULL){
        root = new TreeNode<T>(vec[0]);
        root->parent = NULL;
        num = 1;
    }
    for (size_t i = num; i < vec.size(); i ++){
        flag = insert(vec[i]);
        if(!flag){
            cout << "false at:" << vec[i] << endl;
            break;
        }
    }
    return flag;
}

template<typename T>
bool BSTree<T>::insert(T data){    // 这里采用的是非递归的方法，递归显然会更加容易
    TreeNode<T> *node = new TreeNode<T>(data);
    node->data = data;
    TreeNode<T> *temp = root;
    while(temp){
        if(data < temp->data){
            if(temp->left)
                temp = temp->left;
            else break;
        }
        else if(data > temp->data){
            if(temp->right)
                temp = temp->right;
            else break;
        }
        else
            return false;
    }
    if(data < temp->data){
        temp->left = node;
        node->parent = temp;
    }
    else{
        temp->right = node;
        node->parent = temp;
    }
    return true;
}

template<typename T>
bool BSTree<T>::deletenode(T data){
    if(!search(data)){
        return false;
    }
    TreeNode<T> *temp = root;
    while(temp){
        if(data > temp->data){
            temp = temp->right;
        }
        else if(data < temp->data){
            temp = temp->left;
        }
        else{
            /* 
            这里找到了要删除的那个节点，删除的具体步骤如下：
            找到此节点的左子树上的最右节点为新的根(代替被删除节点)，然后左子树挂到这个节点的左边。
            同时这个节点一定没有右孩子了但也许还有左孩子，把这个左孩子放到原先自己的位置上即可
            */
            TreeNode<T> *p = temp;                  // 用这一根指针指向被删除的节点
            TreeNode<T> *leftsubtree = temp->left;  // 用这一根指针指向被删除节点的左子树
            TreeNode<T> *rightsubtree = temp->right;
            TreeNode<T> *father = temp->parent;   // 先找到被删除节点的父节点
            temp = temp->left;
            if(!temp){
                if(father == NULL){
                    root = rightsubtree;
                }
                else{
                    father->left = rightsubtree;
                    rightsubtree->parent = father;
                }
            }
            else if(!temp->right){
                temp->right = rightsubtree;
                rightsubtree->parent = temp;
                if(father == NULL)
                    root = temp;
                else{
                    father->left = temp;
                }
                temp->parent = father;
            }
            else{
                while(temp && temp->right){
                    temp = temp->right;
                }  // 经过这个步骤我们的temp已经是指向自己左子树的最右节点了！
                TreeNode<T> *newroot = temp;   // 最右节点命名为新根
                TreeNode<T> *newrootleftsubtree = newroot->left;   //  最右节点的左子树应该挂到自己原来的父亲右边去！
                /* 
                所以变量设定完成，接下来开始挂载操作
                */
                newroot->parent->right = newrootleftsubtree;
                if(father == NULL)
                    root = newroot;
                else
                    father->left = newroot;
                newroot->left = leftsubtree;
                newroot->right = rightsubtree;
                leftsubtree->parent = newroot;
                rightsubtree->parent = newroot;
            }
            delete[] p;
        }
    }
    return true;
}

template<typename T>
bool BSTree<T>::search(T data){
    TreeNode<T> *temp = root;
    while(temp){
        if(data > temp->data){
            temp = temp->right;
        }
        else if(data < temp->data){
            temp = temp->left;
        }
        else{
            return true;
        }
    }
    return false;
}


template<typename T>
void MidOrder(TreeNode<T>* root){
    if(root){
        MidOrder(root->left);
        cout << root->data << " ";
        MidOrder(root->right);
    }
}

int main(){
    BSTree<int> tree;
    vector<int> vec{-4, 0, 7, 4, 9, -6, -1, -7};    // 插入时数组需要无重复元素，否则会在中间直接报错
    bool ans = tree.createTree(vec);
    cout << boolalpha << ans << endl;
    MidOrder(tree.getroot());
    cout << endl;
    tree.deletenode(-4);
    MidOrder(tree.getroot());
    return 0;
}