二叉排序树的基本操作

花了一个星期的时间把算法导论中的二叉排序树看完了，下面是我自己按照伪代码实现的代码。

其中有几处和书中的伪代码不一样(是书中的错了)。

1.后继和前驱的函数successor 和presuccessor. 书中有while循环，但是实际上完全用不到。

2.searchBSTree中，要把T = NULL的情况和T->key = key 的情况分开，而书中合在一起放到if中了

3.delete函数，说实话，书中的delete函数太复杂了(虽然很短)，再看了中文翻译版的之后大致掌握了思想，然后自己实现的。

先从思想开始：从要删除结点node的孩子个数角度出发。

①node是叶子结点，无孩子，这种情况最简单，将node的parent指向NULL，node的指针都指向NULL，然后直接删除node

②node只有一个孩子，这种情况也不复杂。讲node的parent指向node的孩子，也是改变一些指针，然后删除node

③node有两个孩子，这种情况最复杂(但是当你回头看的时候也并不是太复杂)。首先要找到node的后继y，用后继y的key值替换node的key值(node->key = y->key)，然后删除y(分两种情况)，如下：

在这里介绍一个我发现的小窍门，那就是：如果node有两个孩子，那么它的后继y最多有一个孩子。所以删除y的时候就按照 ①②的方法删除就搞定了！

#include<iostream>

using namespace std;

typedef struct Node
{
	int key;
	Node *lchild, *rchild;
	Node *parent;
}*BSTree;

void preOrderWalk(BSTree T)
{
	if(T)
	{
		printf("%d\n",T->key);
		preOrderWalk(T->lchild);
		preOrderWalk(T->rchild);
	}
}

void inOrderWalk(BSTree T)
{
	if(T)
	{
		inOrderWalk(T->lchild);
		printf("%d\n",T->key);
		inOrderWalk(T->rchild);
	}
}

void postOrderWalk(BSTree T)
{
	if(T)
	{
		postOrderWalk(T->lchild);
		postOrderWalk(T->rchild);
		printf("%d\n",T->key);
	}
}

Node* MinNode(BSTree T)
{
	BSTree p = T;
	while(p->lchild != NULL)
		p = p->lchild;
	return p;
}

Node* MaxNode(BSTree T)
{
	BSTree p = T;
	while(p->rchild != NULL)
		p = p->rchild;
	return p;
}

Node* successor(BSTree T,Node* x)
{
	if( x->rchild != NULL)
		return MinNode( x->rchild);  
	else 
		return NULL;
	//---------------------------下面这几条语句没看出作用，有上面的不够么？够了，下面的是错误的
	/*BSTree y = NULL;

	while( y != NULL && x == y->rchild)
	{
		x = y;
	}
	return y;*/
}

Node* presuccessor(BSTree T, Node* x)
{
	if(x->lchild != NULL)
		return MaxNode(x->lchild);
	else
		return NULL;
	/*BSTree y = x->parent;
	while(y != NULL && x == y->lchild)
	{
		x = y;
		y = y->parent;
	}
	return y;*/
}

Node* searchBStree(BSTree T,Node* node)
{
	if(T== NULL)
		return NULL;
	if(T->key < node->key)
		return searchBSTree(T->rchild,node);
	else if(T->key >node->key)
		return searchBSTree(T->rchild,node);
	else
		return T;
}
Node* searchBSTree(BSTree T,int key)
{
	if(T != NULL)
	{
		if(T->key == key)
			return T;
		else if(T->key < key)
			return searchBSTree(T->rchild,key);
		else
			return searchBSTree(T->lchild,key);
	}
	else
		return NULL;
}

BSTree InsertBSTree(BSTree T, Node* z)
{
	Node* y = NULL;
	Node* x = T;
	while(x != NULL)
	{
		y = x;
		if( z->key < x->key)
			x = x->lchild;
		else if(z->key == x->key)
			return T;
		else
			x = x->rchild;
	}
	if(y == NULL)
		T = z;
	else if(z->key < y->key)//循环中已经加了等于情况的检测，所以到这里直接插入
	{
		y->lchild = z;
		z->parent = y;
	}
	else
	{
		y->rchild = z;
		z->parent = y;
	}
	return T;
}

BSTree InsertBSTree(BSTree T, int key)//插入在加了parent之后也没错
{
	Node* y = NULL;
	Node* x = T;
	Node* newNode = (BSTree )malloc(sizeof(Node));
	newNode->key = key;
	newNode->lchild = NULL;
	newNode->rchild = NULL;
	newNode->parent = NULL;
	while(x != NULL)
	{
		y = x;
		if( key< x->key)
			x = x->lchild;
		else if (key == x->key)
			return T;
		else
			x = x->rchild;
	}
	if(y == NULL)
	{
		T = newNode;
		newNode->parent = NULL;
	}
	else if(key < y->key)
	{
		y->lchild = newNode;
		newNode->parent = y;
	}		
	else
	{
		y->rchild = newNode;
		newNode->parent = y;
	}
	return T;
}


void deleteNode(BSTree T, int key)//暂时没问题了，如果有问题就是searchBSTree函数的问题
{
	Node* node = searchBSTree(T,key);
	if(node == NULL)
	{
		printf("this key is not in the tree");
		exit(0);
	}
	else
	{
//-----------------------------------------------------------------node是叶子节点，无孩子
		if(node->lchild == NULL && node->rchild == NULL)
		{	if(node->parent->lchild == node)
				node->parent->lchild = NULL;
			else
				node->parent->rchild = NULL;
			delete node;
		}
		else
		{
//-----------------------------------------------------------------node只有一个孩子
			if((node->lchild && node->rchild ) == NULL){
				if(node->lchild != NULL)
				{
					node->parent->lchild = node->lchild;
					node->lchild = NULL;
					node->parent = NULL;
					delete node;
				}
				else
				{
					node->parent->rchild = node->rchild;
					node->rchild = NULL;
					node->parent = NULL;
					delete node;
				}
			}
//-----------------------------------------------------------------node有两个孩子
			else
			{
//-----------------------------------------------------------------既然是node的successor，那么y肯定不会有两个孩子
//-----------------------------------------------------------------为什么不用node的presuccessor呢？试一试，好像可以
				Node* y = presuccessor(T,node);
				node->key = y->key;
				if((y->lchild	!=	NULL))
				{
					if(y->parent->lchild == y)
						y->parent->lchild = y->lchild;
					else
						y->parent->rchild = y->lchild;
					y->lchild = NULL;
					y->parent = NULL;
					delete y;
				}
				else if(y->rchild	!=	NULL)
				{
					if(y->parent->rchild == y)
						y->parent->rchild = y->rchild;
					else
						y->parent->lchild = y->rchild;
					y->rchild = NULL;
					y->parent = NULL;
					delete y;
				}
				else
				{
					if(y->parent->lchild == y)
						y->parent->lchild = NULL;
					else
						y->parent->rchild = NULL;
					y->parent = NULL;
					delete y;
				}
			}
		}
	}
}

BSTree createBSTree()//建立也没有错
{
	BSTree T = NULL;
	int key;
	while(scanf("%d",&key) != EOF)//EOF标志是ctrl+Z
		T = InsertBSTree(T,key);
	return T;
}

int main()
{
	BSTree T = NULL;
	T = createBSTree();
	BSTree succ = (BSTree)malloc(sizeof(Node));
	preOrderWalk(T);
	BSTree node = T->lchild;

	deleteNode(T,5);
	preOrderWalk(T);
	return 0;
}