操作包括二叉搜索树的创建，插入，搜索，寻找前驱后继，删除，左右旋转，插入元素为根结点，以及两棵二叉树的合并。
二叉树的创建很简单，只需要设置 value, left child, right child 即可。
插入的时候递归插入树中合适的位置，通过比较插入元素的值与根结点元素的值，如果小于则递归插入到左子树中，否则递归插入到右子树中。
搜索的时候与插入类似，比较要搜索的值和根结点元素值的大小，若小于则递归到左子树中去查找，否则递归到右子树中去查找。
寻找前驱的方式是在左子树的右结点中去递归寻找，一直找到右结点的右子结点为空，则该右结点即是前驱，寻找后继是在右子树的左结点中去递归寻找，一直找到左结点的左子结点为空，则该左结点即是后继。
结点的删除有些复杂，如果删除的叶结点，则直接删除，否则就要用该结点的前驱中的值来代替该结点中的值，然后递归删除前驱，若不存在前驱，则使用该结点的后继来代替该结点中的值，然后递归删除后继，如果后继也不存在，证明该结点是个叶子结点，直接删除即可。
左旋的方式是让根结点的右结点变成新的根结点，再让新的根结点的左结点指向原来的根结点，再让原来根结点的右结点指向新的根结点原来的左结点，这样操作之后就好像原来的根结点向左旋转了一样。
右旋的操作正好和左旋是对称的，将根结点的左结点变成新的根结点，再让新的根结点的右结点指向原来的根结点，再让原来根结点的左结点指向新的根结点原来的右结点，这样操作之后就好像根结点右旋了一样。
原来的插入操作是直接插入到叶子结点上的，而插入一个元素使其变为根结点就需要旋转操作来实现，如果插入元素大于根结点值，则递归插入到右子树中让其成为右子树的根结点，再将树左旋即可实现，若插入元素小于根结点值，则递归插入到左子树中让其成为左子树中的根结点，再将树右旋即可，递归到最后必然到叶子结点上，此时用插入元素的值来创建一个新的结点，之后依次回程旋转即可实现。
要合并两棵二叉树，基本的思路是遍历其中一棵树，然后递归插入到另一棵树中，优化方式是先将其中一棵树A的根结点插入到另外一棵树B中，此时两棵树的根结点相同，此后树A的左子树插入到树B中必然也是在左子树中，右子树也是同样。所以就可以递归将A的左结点插入到B的左子树中，将A的右结点递归插入到B的右子树中，注意因为这种方式依赖于左右子树和根结点的大小关系，所以只能采用前序递归方式，否则合并之后会破坏树中元素的先后顺序。
具体详见代码：
//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;
}
扫一扫
623
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
