#include<iostream>
#include<assert.h>
using namespace std;
typedef int ElemType;
typedef struct BSTNode//二叉搜索数的结点:左 右 值
{
ElemType data;
BSTNode *LeftChild;
BSTNode *RightChild;
}BSTNode;
typedef struct BSTree
{
BSTNode *root;
}BSTree;
void Init_BSTree(BSTree *bst);//初始化二叉搜索数(实现)
bool insert(BSTree *bst,ElemType x);//插入节点(实现)
bool insert(BSTNode *&t,ElemType x);
ElemType max(BSTree *bst);//求最大值(实现)
ElemType max(BSTNode *t);
ElemType min(BSTree *bst);//求最小值(实现)
ElemType min(BSTNode *t);
void sort(BSTree *bst);//排序(实现)
void sort(BSTNode *t);
bool remove(BSTree *bst,ElemType x);//删除(实现)
bool remove(BSTNode *&t,ElemType x);
BSTNode* Find(BSTree *bst,ElemType x );//按值查找查找
BSTNode* Find(BSTNode *t,ElemType x);
void MidShowBSTree(BSTree *bst);//中序遍历显示(实现)
void MidShowBSTree(BSTNode *t);
void PreShowBSTree(BSTree *bst);//前序遍历显示(实现)
void PreShowBSTree(BSTNode *t);
void PostShowBSTree(BSTree *bst);//后序遍历结果显示(实现)
void PostShowBSTree(BSTNode *t);
BSTNode* _BuyNode();//购买节点(实现)
void main()
{
BSTree bst;
BSTNode *p=NULL;
Init_BSTree(&bst);
int ar[]={23,45,19,22};
int n=sizeof(ar)/sizeof(int);
ElemType maxdata,mindata;
for(int i=0;i<n;i++)
{
insert(&bst,ar[i]);//插入
}
//sort(&bst);//相当于中序遍历
remove(&bst,23);
cout<<"前序遍历结果为:"<<endl;
PreShowBSTree(&bst);
cout<<endl;
cout<<"中序遍历结果为:"<<endl;
MidShowBSTree(&bst);
cout<<endl;
cout<<"后序遍历结果为:"<<endl;
PostShowBSTree(&bst);
maxdata=max(&bst);
mindata=min(&bst);
cout<<endl;
cout<<"最大数据为:"<<maxdata<<endl;
cout<<"最小数据为:"<<mindata<<endl;
p=Find(&bst,22);
if(p==NULL)
{
cout<<"没有找到"<<endl;
}
else
cout<<"找到"<<endl;
}
void Init_BSTree(BSTree *bst)
{
bst->root=NULL;//初始化,让根节点为空
}
BSTNode* _BuyNode(ElemType x)
{
BSTNode *s=(BSTNode*)malloc(sizeof(BSTNode));
assert(s!=NULL);
s->data=x;
s->LeftChild=NULL;
s->RightChild=NULL;
return s;
}
bool insert(BSTree *bst,ElemType x)
{
return insert(bst->root,x);
}
bool insert(BSTNode *&t,ElemType x)
{
if(t==NULL)
{
t=_BuyNode(x);
return true;
}
else if(t->data<x)
{
insert(t->RightChild,x);
}
else if(t->data>x)
{
insert(t->LeftChild,x);
}
return false;
}
ElemType max(BSTree *bt)
{
return max(bt->root);
}
ElemType max(BSTNode *t)
{
if(t==NULL)
return -1;
else
{
while(t->RightChild!=NULL)
{
t=t->RightChild;
}
return t->data;
}
}
ElemType min(BSTree *bt)
{
return min(bt->root);
}
ElemType min(BSTNode *t)
{
if(t==NULL)
return -1;
else
{
while(t->LeftChild!=NULL)
{
t=t->LeftChild;
}
return t->data;
}
}
void sort(BSTree *bst)
{
sort(bst->root);
}
void sort(BSTNode *t)
{
if(t==NULL)
return;
else
{
sort(t->LeftChild);
cout<<t->data<<" ";
sort(t->RightChild);
}
}
bool remove(BSTree *bt,ElemType x)
{
return remove(bt->root,x);
}
bool remove(BSTNode *&t,ElemType x)
{
if(t==NULL)
return false;
if(x<t->data)
remove(t->LeftChild,x);
else if(x>t->data)
remove(t->RightChild,x);
else//相等,找到,找到的情况分为三种:找到的节点有左右子树,找到的节点有左子树或者右子树,找到的节点既没有左子树也没有右子树
{
BSTNode *p=NULL;
if(t->LeftChild!=NULL&&t->RightChild!=NULL)
{
p=t->RightChild;
while(p->LeftChild!=NULL)
{
p=p->LeftChild;
}
t->data=p->data;
remove(t->RightChild,p->data);
}
else
{
p=t;
if(t->LeftChild==NULL)
{
t=t->RightChild;
}
else if(t->RightChild==NULL)
{
t=t->LeftChild;
}
free(p);
p=NULL;
}
}
return true;
}
void MidShowBSTree(BSTree *bst)
{
MidShowBSTree(bst->root);
}
void MidShowBSTree(BSTNode *t)
{
if(t==NULL)
return;
else
{
MidShowBSTree(t->LeftChild);
cout<<t->data<<" ";
MidShowBSTree(t->RightChild);
}
}
void PreShowBSTree(BSTree *bst)
{
PreShowBSTree(bst->root);
}
void PreShowBSTree(BSTNode *t)
{
if(t==NULL)
return;
else
{
cout<<t->data<<" ";
PreShowBSTree(t->LeftChild);
PreShowBSTree(t->RightChild);
}
}
void PostShowBSTree(BSTree *bt)
{
PostShowBSTree(bt->root);
}
void PostShowBSTree(BSTNode *t)
{
if(t==NULL)
{
return;
}
else
{
PostShowBSTree(t->LeftChild);
cout<<t->data<<" ";
PostShowBSTree(t->RightChild);
}
}
BSTNode* Find(BSTNode* t,ElemType x)
{
if(t==NULL)
return NULL;
else
{
if(t->data>x)
Find(t->LeftChild,x);
else if(t->data<x)
{
Find(t->RightChild,x);
}
else
return t;
}
}
BSTNode* Find(BSTree *bt,ElemType x)
{
return Find(bt->root,x);
}
二叉搜索树的相关操作:插入节点,删除节点,排序,查找,最大值,最小值,前序,中序,后序遍历(主要用到递归的方法)
最新推荐文章于 2022-08-25 17:33:00 发布