二叉排序树

/*
  Name: 二叉排序树相关操作
  Author: Unimen
  Date: 2011/10/8 13:14:21
*/

/*
删除结点比较麻烦，总结如下：
4大种情况
1、结点p无右孩子：将该点的左孩子变为其在双亲中的同位孩子
   1、p为其双亲的左孩子时将其的左孩子变为双亲的左孩子
   2、p为其双亲的右孩子时将其的左孩子变为双亲的右孩子
2、结点p无左孩子：将该结点的右孩子变为其在双亲中的同位孩子
   1、p为其双亲的左孩子时将其的右孩子变为双亲的左孩子
   2、p为其双亲的右孩子时将其的右孩子变为双亲的右孩子
3、节点p既无左孩子也无右孩子：前面的两种处理其实已经包含了这种情况
4、节点p既有左孩子也有右孩子：两种处理办法：后继，前驱
    一、后继替换：先找到p的后继此时分两种情况
    	1、后继s就是p的右孩子（也就说s无左子树），这时用s结点的值替换p结点的值，将s的
    	   右孩子变为p的右孩子
    	2、后继s是p右孩子的左子树中的最后一个左节点，这时用s结点的值替换p结点的值，将s的
    	   右孩子变为s双亲的左孩子
    二、前驱替换：同样先找到p的前驱，这时也有两种情况
        1、前驱s就是p的左孩子（也就说s无右子树），这时用s结点的值替换p结点的值，将s的
           左孩子变为p的左孩子
        2、前驱s是p左孩子的右子树中的最后一个右结点，这时用s结点的值替换p结点的值，将s的
           左孩子变为s双亲的右孩子
    注：前驱和后继方法差不多，画出图来就一目了然了
*/

#include <iostream>
#include <cassert>
using namespace std;

//数据结构
const int maxn = 10000;
typedef struct node
{
	int nData;
	struct node *pLChild, *pRChild;
}BST, *PBST;

//插入操作，建树时将用其
void Insert(PBST &pDst, const PBST &pSrc)
{
	if (NULL == pDst)
	{
		pDst = pSrc;
	}
	else if (pDst->nData < pSrc->nData)
	{
		Insert(pDst->pRChild, pSrc);
	}
	else if (pDst->nData > pSrc->nData)
	{
		Insert(pDst->pLChild, pSrc);
	}
	else 
	{
		return ;
	}
}

//创建  以ctrl+z结束输入
void Create(PBST &root)
{
	int nInput;
	PBST temp;
	root = NULL;
	while (cin>>nInput)
	{
		temp = new BST;
		temp->nData = nInput;
		temp->pLChild = NULL;
		temp->pRChild = NULL;
		Insert(root, temp);
	}
	//使输入流处于正确状态 
	cin.clear();
	char cTemp;
	cTemp = cin.get();
}

//中序遍历
void InOrder(PBST root)
{
	assert(root);
	
	PBST stack[maxn];
	int top = 0;
	PBST temp = NULL;
	while (root!=NULL || top>0)
	{
		if (root != NULL)
		{
			++top;
			stack[top] = root;
			root = root->pLChild;
		}
		else
		{
			temp = stack[top];
			--top;
			cout<<temp->nData<<" ";
			root = temp->pRChild;
		}
	}
}

//删除特定结点
void Delete(PBST pDelete, PBST pParent)
{
	assert (pDelete && pParent);
	
	PBST q = NULL;
	PBST s = NULL;
	
	//右子树为空 
	if (pDelete->pRChild == NULL)
	{
		if (pParent->pLChild == pDelete) //如果pDelete为pParent的左子树
		{
			pParent->pLChild = pDelete->pLChild;
		} 
		else
		{
			pParent->pRChild = pDelete->pLChild;  //如果pDelete为pParent的右子树
		}
		delete pDelete;
	}
	//左子树为空
	else if (pDelete->pLChild == NULL)
	{
		if (pParent->pLChild == pDelete) //如果pDelete为pParent的左子树
		{
			pParent->pLChild = pDelete->pRChild;
		}
		else                             //如果pDelete为pParent的右子树
		{
			pParent->pRChild = pDelete->pRChild;
		}
		delete pDelete;
	}
	//左右子树都不为空
	//前驱方法
	else
	{
		q = pDelete;
		s = pDelete->pLChild;
		while (s->pRChild)
		{
			q = s;
			s = s->pRChild;
		}
		pDelete->nData = s->nData;
		if (pDelete != q)                 //第二种情况
		{
			q->pRChild = s->pLChild;
		}
		else                             //第一种情况
		{
			q->pLChild = s->pLChild;
		}
		delete s;
	}
	/*后继方法
	else
	{
		q = pDelete;
		s = pDelete->pRChild;
		while (s->pLChild)
		{
			q = s;
			s = s->pLChild;
		}
		pDelete->nData = s->nData;
		if (q != pDelete)                   //第一种情况
		{
			q->pLChild = s->pRChild;
		}
		else                                 //第二种情况
		{
			pDelete->pRChild = s->pRChild;
		}
	}
	
	*/
}

//查找给定值的结点的指针，pParent返回其双亲结点 
void SearchBST(PBST root, PBST &pParent, PBST &pPoint, const int &value)
{
	assert(root);
	
	if (root->nData == value)
	{
		pParent = root;
		pPoint = root;
	}
	else if (root->pLChild!=NULL && root->pLChild->nData==value)
	{
		pParent = root;
		pPoint = root->pLChild;
	}
	else if (root->pRChild!=NULL && root->pRChild->nData==value)
	{
		pParent = root;
		pPoint = root->pRChild;
	}
	else if (value < root->nData)
	{
		SearchBST(root->pLChild, pParent, pPoint, value);
	}
	else 
	{
		SearchBST(root->pRChild, pParent, pPoint, value);
	}
}

int main()
{
	PBST root = NULL;
	PBST pDelete = NULL;
	PBST pParent = NULL;
	int value;
	cout<<"请输入待排序的数字序列(ctrl+z结束)：";
	Create(root);
	cout<<"按递增排：";
	InOrder(root);
	cout<<endl;
	
	cout<<"输入要删除的数：";
	cin>>value;
	
	SearchBST(root, pParent, pDelete, value);
	if (pParent!=NULL && pDelete!=NULL)
		Delete(pDelete, pParent);
	else
		cout<<"查找结点不存在，无法进行删除！"<<endl;
	cout<<"删除后：";
	InOrder(root);
	cout<<endl;
	return 0;
}