二叉搜索树的相关操作

//BST.cpp

#include <malloc.h>
#include <iostream>
#include "binary_tree.h"//defined BST struct
#include "print_binary_tree.h"
//the node of a tree, included in binary_tree.h
#include <stdlib.h>
#include <time.h>
using namespace std;

//create node with value, left child and right child 
struct bst_node* create_bst_node(int value, struct bst_node* l, struct bst_node* r){
    struct bst_node* t =(struct bst_node*) malloc(sizeof *t);//should call free() when finished
    t->value = value;
    t->l = l;
    t->r = r;
    return t;
}

//bst insert
struct bst_node* bst_insert(struct bst_node* root, int value){
    if(root == NULL) 
        return create_bst_node(value,NULL,NULL);//tree is empty
    //if root is not NULL
    if(value < root->value)
        root->l = bst_insert(root->l,value);//insert into left child
    else if (value > root->value)
        root->r = bst_insert(root->r,value);//
    return root;
}

//bst search, the keyword "struct" can be omitted
struct bst_node* bst_search(struct bst_node* bst_root, int value){
    if(bst_root == NULL)
        return NULL;
    if(value < bst_root->value){
        return bst_search(bst_root->l, value);
    }else if(value > bst_root->value){
        return bst_search(bst_root->r, value);
    }
    return bst_root;//neither greater nor less, must be equal
}
//predecessor 
bst_node* predecessor(bst_node* t){
    t = t->l;
    while(t->r != NULL){
        t = t->r;
    }
    return t;
}
//successor 
bst_node* successor(bst_node* t){
    t = t->r;
    while(t->l != NULL){
        t = t->l;
    }
    return t;
}
//bst remove
bst_node* bst_remove(bst_node* t, int value){
    if(t == NULL) return NULL;
    if(value < t->value){
        t->l = bst_remove(t->l,value);//return a new left subtree which has removed the value
    }else if(value > t->value){
        t->r = bst_remove(t->r,value);//return a new right subtree which has removed the value
    }else{//have found the value
        if(t->l != NULL){//get the predecessor first, then remove predecessor in left subtree
            t->value = predecessor(t)->value;
            t->l = bst_remove(t->l,t->value);
        }else if(t->r != NULL){//get the successor first, then remove successor in right subtree
            t->value = successor(t)->value;
            t->r = bst_remove(t->r,t->value);
        }else{
            //now t is a leaf node,and remove it directly
            free(t);
            t = NULL;
        }
    }
    return t;
}

//bst rotate
//bst rotate right, return left child
bst_node* bst_rot_r(bst_node* t){
    if(t == NULL || t->l ==NULL) return t;
    else{
        bst_node* tl = t->l;
        t->l = tl->r;
        tl->r = t;
        return tl;
    }
}
//bst rotate left, return right child
bst_node* bst_rot_l(bst_node* t){
    if(t == NULL || t->r ==NULL) return t;
    else{
        bst_node* tr = t->r;
        t->r = tr->l;
        tr->l = t;
        return tr;
    }
}
//insert node to root
bst_node* bst_insert_to_root(bst_node* t, int value){
    if(t == NULL)//insert to leaf 
        return create_bst_node(value,NULL,NULL);
    if(value > t->value){
        t->r = bst_insert_to_root(t->r,value);
        return bst_rot_l(t);
    }else if(value < t->value){
        t->l = bst_insert_to_root(t->l,value);
        return bst_rot_r(t);
    }else{
        return t;
    }
}

//merge two trees
bst_node* bst_merge_mine(bst_node* a, bst_node* b)
{
    if (b==NULL) return a;
    if (a==NULL) return b;
    
    //get the value from a, and insert the value into b
    //我是直接从根结点开始插入
    //我的算法前序递归和后序递归都是可以的
    //中序递归会生成一颗倾斜的树，应为中序遍历结点的值往后依次是增大的
    //最后的一个元素是最大的，又成为了根结点，所以合成树是向右上方倾斜的
    b = bst_merge_mine(a->l,b);
    b = bst_merge_mine(a->r,b);
    b = bst_insert_to_root(b,a->value);//let root of a tobe the root of merged tree
    
    return b;
}

//merge two trees
//基本思想还是遍历a中的元素，递归插入到b中
//但是这个比我的算法稍微好的地方在于将a和b的根结点设置为一样之后
//每次插入可以不从b的根结点开始，因为此时a的左树插入之后必然在合并之树的左边，
//a的右子树插入之后也必然在合并之树的右边，所以插的时候a的左子树可以直接插到b的左子结点去，
//同理a的右结点可以插到b的右子树中去
bst_node* bst_merge(bst_node* a, bst_node* b)
{//整个递归过程是前序递归：root->left child->right child
    //从一开始想到这两个条件并不困难，
    //但是在递归的时候这两个条件却起到了很大作用
    //这两个条件配合下面的左右子树赋值语句b->l=... b->r=...发挥了很妙的作用
    if (a==NULL) return b;//
    if (b==NULL) return a;//这个条件很微妙，在递归的时候表现的很巧妙
    //注意，因为此处利用了左右子树和根的相互关系，所以只能是前序递归
    //中序递归和后序递归都会破坏树中元素的先后关系
    b = bst_insert_to_root(b,a->value);//set a to root
    b->l = bst_merge(a->l, b->l);//将a的左结点取出，插到b的左子树中去
    b->r = bst_merge(a->r, b->r);//将a的右结点取出，插到b的右子树中去
    free(a);//每次合并完后将a的子树释放
    a = NULL;
    return b;
}


int main(){
    //create_bst_node();
    //srand((unsigned)time(NULL));//使用系统时间初试化随机种子
    int value = rand()%123;
    bst_node* bst_root = create_bst_node(value, NULL, NULL);
    //for(int k=0; k<39; k++){
    for(int k=0; k<9; k++){
        value = rand()%123;
        bst_insert(bst_root, value);
    }

    print_binary_tree(bst_root);

    value = rand()%123;
    bst_node* bst_root2 = create_bst_node(value, NULL, NULL);
    //for(int k=0; k<39; k++){
    for(int k=0; k<9; k++){
        value = rand()%123;
        bst_insert(bst_root2, value);
    }

    print_binary_tree(bst_root2);
    bst_node* m = bst_merge(bst_root,bst_root2);
    print_binary_tree(m);
    return 0;
}