二叉搜索树的搜索、排序、插入、删除

#include <iostream>  
#include<stack>
#define MAXLINE 5
using namespace std;  
struct Node
{
	int data;
	struct Node * lchild;
	struct Node * rchild;
};
void insertBinaryTree(struct Node *root,int data)
{
	struct Node *p1,*p2,*pData;
	pData=(struct Node *)malloc(sizeof(struct Node));
	pData->data=data;
	pData->lchild=NULL;
	pData->rchild=NULL;
	p1=p2=root;
	while(p1)
	{	
		p2=p1;
		if(p1->data>data)	//左子树
			p1=p1->lchild;
		else
			p1=p1->rchild;
	}
	if(p2->data>data)		//数据放在p2的左子树上.
		p2->lchild=pData;
	else
		p2->rchild=pData;
}
struct Node * getFatherNode(struct Node *root,struct Node *pData)
{
	struct Node *p1,*p2;
	p1=root;
	p2=NULL;
	while(p1 && p1!=pData)
	{
		p2=p1;
		if(p1->data>pData->data)
			p1=p1->lchild;
		else if(p1->data<pData->data)
			p1=p1->rchild;
		else if(p1->lchild->data==pData->data)		//左子树搜索
			p1=p1->lchild;
		else if(p1->rchild->data==pData->data)
			p1=p1->rchild;
	}
	if(!p1)
		return NULL;
	return p2;
}
struct Node * getSuccessor(struct Node * root,struct Node *pData)		//寻找后继节点
{
	struct Node *p;
	if(pData->rchild)
	{
		p=pData->rchild;
		while(p->lchild)
			p=p->lchild;
		return p;
	}
	p=getFatherNode(root,pData);
	while(!p && p->rchild==pData)
	{
		pData=p;
		p=getFatherNode(root,p);
	}
	return p;
}
struct Node *getPredecessor(struct Node *root,struct Node *pData)		//寻找前驱节点
{
	struct Node *p;
	if(pData->lchild)
	{
		p=pData->lchild;
		while(p->rchild)
			p=p->rchild;
		return p;
	}
	p=getFatherNode(root,pData);
	while(!p && p->lchild==pData)
	{
		pData=p;
		p=getFatherNode(root,p);
	}
	return p;
}

struct Node * createBinaryTree(int *array,int n)
{
	if(n<=0)
		return NULL;
	struct Node *root;
	root=(struct Node *)malloc(sizeof(struct Node));
	root->data=array[0];
	root->rchild=NULL;
	root->lchild=NULL;
	int i=1;
	for(i=1;i<n;i++)
		insertBinaryTree(root,array[i]);
	return root;
}
#if 0
void print(struct Node *root)
{
	if(!root)
		return;
	print(root->lchild);
	cout<<root->data<<" ";
	print(root->rchild);
}
#endif
void inorderTraversal(struct Node *root)
{
	stack<struct Node *>st;
	struct Node *p=root;
	struct Node *pData;
	st.push(root);
	while(!st.empty())		//只要堆栈非空
	{
		p=st.top();
		while(p)
		{
			st.push(p->lchild);
			p=p->lchild;
		}					//让p指向最左子节点的左子节点
		st.pop();			//空指针堆栈;
		if(!st.empty())
		{
			pData=st.top();			//要访问的元素
			cout<<pData->data<<" ";
			st.pop();
			st.push(pData->rchild);
		}
	}
}
struct Node * maxBinaryTree(struct Node *root)
{
	struct Node *p=root;
	while(p->rchild)
		p=p->rchild;
	return p;
}
struct Node * minBinaryTree(struct Node *root)
{
	struct Node *p=root;
	while(p->lchild)
		p=p->lchild;
	return p;
}
struct Node * binarySearch(struct Node *root,int data)
{
	struct Node *p=root;
	while(p)
	{
		if(p->data>data)		//在左子树上
			p=p->lchild;
		else if(p->data<data)	//在右子树上
			p=p->rchild;
		else					//找到
			return p;
	}
	return NULL;
}
void deleteBinaryTree(struct Node *root,int data)
{
	struct Node *pData=root,*p;
	pData=binarySearch(root,data);//p指向要删除的节点.
	if(!pData)			//p==NULL表示未找到元素data
		return;
	p=pData;
	if(pData->lchild && pData->rchild)	//左孩子右孩子均存在则删除其后继节点，然后将后继节点的值放到pData中
		p=getSuccessor(root,pData);
	//删除节点p，可以确定p节点只有一个孩子后者没有孩子
	struct Node *pFather;
	if(!p->lchild && !p->rchild)		//左孩子右孩子都不存在
	{
		pFather=getFatherNode(root,p);
		if(pFather->lchild==p)
			pFather->lchild=NULL;
		else 
			pFather->rchild=NULL;
	}
	else if(p->rchild && !p->lchild)	//右孩子存在
	{
		pFather=getFatherNode(root,p);
		if(pFather->lchild==p)
			pFather->lchild=p->rchild;
		else
			pFather->rchild=p->rchild;
	}
	else if(!p->rchild && p->lchild)		//左孩子存在
	{
		pFather=getFatherNode(root,p);
		if(pFather->lchild==p)
			pFather->lchild=p->lchild;
		else 
			pFather->rchild=p->lchild;
	}

	if(pData->lchild && pData->rchild)
		pData->data=p->data;
	return ;
}
int _tmain(int argc, _TCHAR* argv[])
{
	
	int array[MAXLINE];
	cout<<"please input "<<MAXLINE<<" numbers"<<endl;
	int i=0;
	for(i=0;i<MAXLINE;i++)
		cin>>array[i];
	cout<<"the numbers input are:"<<endl;
	for(i=0;i<MAXLINE;i++)
		cout<<array[i]<<" ";
	cout<<endl;

	cout<<"numbers ordered are:"<<endl;						
	struct Node *root=createBinaryTree(array,MAXLINE);	//构建二叉树
	inorderTraversal(root);							//排序

	struct Node *p=maxBinaryTree(root);					//查找最大值
	cout<<endl<<"max of binary tree is "<<p->data<<endl;

	p=minBinaryTree(root);								//查找最小值
	cout<<"min of binary tree is "<<p->data<<endl;
	
	cout<<"please input the number you want to search"<<endl;
	int data;
	cin>>data;
	p=binarySearch(root,data);							//二叉树查找指定值
	if(p)
	{
		cout<<"find data "<<p->data<<endl;
		cout<<"it's predecessor is "<<getPredecessor(root,p)->data<<endl;
		cout<<"it's successor is "<<getSuccessor(root,p)->data<<endl;
		deleteBinaryTree(root,p->data);
		inorderTraversal(root);
	}
	else
		cout<<"can't find data "<<data<<endl;
	cin.get();
	cin.get();
	return 0;
}