二叉搜索树的简单实现（Binary Search Tree）

一、二叉搜索树的概念

二、二叉搜索树的结构

三、二叉搜索树的复杂度

四、二叉搜索树的实现

#include <iostream>
#include <cstdio>
using namespace std;
struct node{
int val;
node *lch,*rch;
node(){
val = 0; lch = rch = NULL;
}
};
node* insert(node* p,int x){ //插入操作
if(p == NULL){
node* q = new node;
q->val = x;
q->lch = q->rch = NULL;
return q;
}
else{
if(x < p->val)
p->lch = insert(p->lch,x);
else
p->rch = insert(p->rch,x);
return p;
}
}
bool find(node* p,int x){
if(p == NULL)
return false;
else if(x == p->val) return true;
else if(x < p->val) return find(p->lch,x);
else return find(p->rch,x);
}
//删除操作
//1.需要删除的结点没有左儿子，把右儿子提上去
//2.需要删除的结点的左儿子没有右儿子，把左儿子提上去
//3.以上两种情况都不满足，把左儿子子孙中最大的结点提到要删除的结点位置。
node* remove(node* p,int x){
if(p == NULL) return NULL;
else if(x < p->val) p->lch = remove(p->lch,x);
else if(x > p->val) p->rch = remove(p->rch,x); //将返回的值 赋值给 右儿子
else if(p->lch == NULL){  //1.
node* q = p->rch;
delete p;
return q;
}
else if(p->lch->rch == NULL){ //2.
node* q = p->lch;
q->rch = p->rch;
delete p;
return q;
}
else {
node* q;
for(q = p->lch;q->rch->rch != NULL;q = q->rch);
node *r = q->rch; //将找到的”左儿子子孙中最大的结点“ 赋值给r
q->rch = r->lch;  //将最大结点原先的左子节点赋值给 上一级结点右结点
//经过这两步，最大结点已经提出来了
r->lch = p->lch;  //最大结点取代被删除结点的位置
r->rch = p->rch;
delete p;
return r;
}
return p;
}
void print(node* tmp){
if(tmp == NULL){
return ;
}
else{
print(tmp->lch); //递归向左子树找到最小的值
printf("%d\n",tmp->val);  //输出 (中序遍历)
print(tmp->rch); //再找右子树
}
}
int main(){
node* tmp;
tmp = NULL; //不要忘记清空
tmp = insert(tmp,7);   //测试数据
tmp = insert(tmp,2);
tmp = insert(tmp,15);
tmp = insert(tmp,10);
tmp = insert(tmp,11);
tmp = insert(tmp,17);
tmp = insert(tmp,16);
tmp = insert(tmp,19);
tmp = insert(tmp,8);
tmp = remove(tmp,15);
print(tmp);
int num = 15;
if(find(tmp,num))
printf("Find %d !\n",num);
else printf("Not find!\n");
num = 16;
if(find(tmp,num))
printf("Find %d !\n",num);
else printf("Not find!\n");
return 0;
}

另一种实现方法

#include<iostream>
#include<cstdio>
using namespace std;
typedef int ElementType;
struct node{
ElementType Data;
node *Left,*Right;
node(){
Left = Right = NULL;
Data = 0;
}
};
typedef node* BinTree;
/* BinTree Find(ElementType X,BinTree BST){ //递归方法， 尾递归，效率低
if(!BST)
return NULL;
if(X >BST->Data)
return Find(X , BST->Right);
else  if(X < BST->Data)
return Find(X , BST->Left);
else //X == BST->Data;
return BST ;
} */
BinTree Find(ElementType X, BinTree BST){ //迭代版效率高， 可将尾递归 改为迭代函数
while(BST){
if(X >BST->Data)
BST = BST->Right;
else if(X <BST->Data)
BST = BST->Left;
else
return BST;
}
return NULL;
}
BinTree FindMin(BinTree BST){ //迭代版本
while(BST->Left)
BST = BST->Left;
return BST;
}
BinTree FindMax(BinTree BST){ //递归版本
if(BST->Right)
return FindMax(BST->Right);
return BST;
}
BinTree Insert(ElementType X,BinTree BST){
if(!BST){
BST = new node;
BST->Data = X;
BST->Left = BST->Right = NULL;
}
else{
if(X < BST->Data)
BST->Left = Insert(X , BST->Left);
else //这样保证了重复节点的插入。即X == BST->Data;
BST->Right = Insert(X , BST->Right);
}
return BST;
}
//删除操作
// 1、要删除的 节点 只有一个儿子 删除当前节点，将这个儿子提到当前位置；
// 2、要删除的节点 没有儿子，直接删除即可；
// 3、要删除的节点既有左儿子，又有右儿子。（这里有两种处理方法）
//      1 。 找到右儿子后代中最小的那个儿子 ，覆盖当前位置， 删除那个儿子。
//	2 。 找到左儿子后代最大的那个儿子，覆盖当前位置， 删除那个儿子。
BinTree Delete(ElementType X , BinTree BST){
BinTree Tmp;
if(!BST) printf("要删除的元素未找到\n");
else if(X < BST->Data)
BST->Left = Delete(X , BST->Left); //递归的删除左子树
else if(X > BST->Data)
BST->Right = Delete(X, BST->Right);
else//找到要删除的节点
if(BST->Left && BST->Right){ //如果既有左儿子又有右儿子
Tmp = FindMin(BST -> Right); //这里我们找到右儿子中最小的儿子
BST->Data = Tmp->Data; //赋值给当前节点
BST->Right = Delete(BST->Data , BST->Right); //递归的删除那个右儿子
}
else{ //被删除的节点的子节点只有一个，或者没有
Tmp = BST;
if(!BST->Left) //如果左边为空
BST = BST->Right;    //这里隐式的处理了左右儿子都为空的情况。
else if(!BST->Right)
BST = BST->Left;
delete Tmp; //删除当前节点
}
return BST;
}
void Traverse(BinTree BST){ //中序遍历二叉搜索树
if(!BST)
return ;
else{
Traverse(BST->Left);
printf("%d\n" , BST->Data);
Traverse(BST->Right);
}
}
int main(){
BinTree tree = NULL;
tree = Insert(5,tree);
tree = Insert(3,tree);
tree = Insert(2,tree);
tree = Insert(5,tree);
tree = Insert(7,tree);
tree = Insert(67,tree);
Traverse(tree);
cout<<"------------"<<endl;
tree = Delete(67,tree);
tree = Delete(9,tree);
BinTree tmp  = Find(2,tree);
printf("查找 %d\n",tmp->Data);
Traverse(tree);
return 0;
}