数据结构—二叉搜索树的创建、结点的插入和删除

<span style="font-family:Courier New;font-size:14px;">#define TRUE        1
#define ERROR       0
#define OK          1
#define REEOR       1
#define INFEASIBLE -1
#define OVERFLOW   -2
typedef int Status;
</span>

<span style="font-family:Courier New;font-size:14px;">//二叉查找树(BST)的创建，插入、删除操作
//二叉查找树：（Binary Search Tree）又称为二叉搜素树、二叉排序树。其或者是一棵空树，或者是具有以下性质的二叉树
//(1)若其左子树不为空，则左子树上所有节点至均小于其根节点值
//(2)若其右子树不为空，则右子树上所有节点至均大于其根节点值
//(3)其左右子树也分别为二叉查找树
//即左 < 中 < 右，BST的中序遍历是严格递增的，且不允许有重复元素
//在二叉查找树中插入包括了寻找的过程，当未找到时执行插入
#include<stdio.h>
#include <stdlib.h>
#include "StudyBST.h"
typedef struct node
{
	int key;
	struct node *lchild,*rchild;
}Node,*BST;
//在给定的BST中插入结点，其数据域为element，使之成为新的BST
bool BSTInsert(Node *&p,int element)
{
	if (NULL==p)                   //递归终止条件(根节点创建)
	{
		p=(Node *)malloc(sizeof(Node));
		p->key=element;
		p->lchild=p->rchild=NULL;
		return true;
	}
	else if(element==p->key)   //插入值已存在，则插入失败 
		return false;
	else if (element<p->key)
		return BSTInsert(p->lchild,element);  //递归实现,比根节点小，放在左边
	else
	return BSTInsert(p->rchild,element);
}

//建立BST
bool CreateBST(Node *&T,int a[],int n)
{
	T=NULL;
	int i;
	for (i=0;i<n;i++)
	{
		if(!BSTInsert(T,a[i]))   //添加结点不成功
		     break;
	}
	if (i==n)
	    return true;
	else
		return false;
}
//先序遍历
void PreOrder(BST T)
{
	if(T)
	{
		printf("%d ",T->key);
		PreOrder(T->lchild);
		PreOrder(T->rchild);
	}
}
//中序遍历
void MidOrder(BST T)
{
	if(T)
	{
		MidOrder(T->lchild);
		printf("%d ",T->key);
		MidOrder(T->rchild);
	}
}
//后序遍历
void PostOrder(BST T)
{
	if(T)
	{
		PostOrder(T->lchild);
		PostOrder(T->rchild);
		printf("%d ",T->key);
	}
}
//《数据结构（C语言版）》清华版,二叉搜索树的插入要先查找，再插入
//二叉搜索树的查找
BST SearchBst(BST T,int key)
{
	if ((!T)||(T->key==key))
		return (T);              //查找结束
	else if(T->key<key)        //在右子树查找
		return (SearchBst(T->rchild,key));
	else
		return (SearchBst(T->lchild,key));
}
//二叉树搜索树查找，查找到返回true,否则返回false,并返回查找路径上访问的最后一个结点
Status SearchBST2(Node *T,int key,Node * f,Node *&p)
{
	if (!T)
	{
		p=f;
		return FALSE;
	}
	else if(T->key==key)
	{
		p=T;
		return TRUE;
	}
	else if(T->key>key)
		return SearchBST2(T->lchild,key,T,p);
	else 
		return SearchBST2(T->rchild,key,T,p);
}
//二叉搜索树的插入
Status InsertBST(Node *T,int key)
{
	//当二叉搜索树中没有元素key时，进行插入
	Node *p=(Node *)malloc(sizeof(Node));
	if(!SearchBST2(T,key,NULL,p))
	{
		Node *s=(Node *)malloc(sizeof(Node));
		s->key=key;
		s->lchild=NULL;
		s->rchild=NULL;
		if(!p)        //结点s为根结点
			T=s;
		else if(p->key>key)
			p->lchild=s;
		else
			p->rchild=s;
		return TRUE;
	}
	else
		return FALSE;
}
//二叉搜索树的结点删除
Status Delete(Node *p)
{
	Node *q;
	if (!p->rchild)       //结点p没有右子树
	{
		q=p;
		p=p->lchild;
		free(q);
	}
	else if (!p->lchild)   //结点p没有左子树
	{
		q=p;
		p=p->rchild;
		free(q);
	}
	else          //结点的左右子树均不为空
	{
		q=p;
		Node *s=p->lchild;
		while(s->rchild)        //转左，然后向右到尽头
		{
			q=s;
			s=s->rchild;
		}
		p->key=s->key;          //s指向被删除结点的前驱(中序遍历时)
		if(q!=p)
			q->rchild=s->lchild;  //重接q的右子树
		else
			q->lchild=s->lchild;  //重接q的左子树
	free(s);
	}
	return TRUE;
}
Status DeleteBST(Node *T,int key)
{
	if (!T)
	   return FALSE;
	else if(T->key==key)
		Delete(T);
	else if(T->key>key)
		return DeleteBST(T->lchild,key);
	else 
		return DeleteBST(T->rchild,key);
}
//树的销毁
void DestoryBST(BST T)
{
	if (T)
	{
		DestoryBST(T->lchild);
		DestoryBST(T->rchild);
		delete T;
	}
}
//测试程序
int main()
{
	int a[]={4,5,2,1,0,9,3,7,6,8};
	int len=sizeof(a)/sizeof(a[0]);
	Node *T,*temp;
    if (CreateBST(T,a,len))
	{
		PreOrder(T);
		printf("\n");
		MidOrder(T);
		printf("\n");
	}
	else
		printf("data error,cannot create binary search tree!\n");
	if (temp=SearchBst(T,9))
	{
	     printf("Search successful!\n");
		 printf("%d\n",temp->key);
	}
// 	if(BSTInsert(T,-1))
// 		MidOrder(T);
	if (InsertBST(T,10))
	    MidOrder(T);
	printf("\n");
	DeleteBST(T,10);
	MidOrder(T);
	printf("\n");
	DestoryBST(T);
	system("pause");
	return 0;
}</span>