BST树，二叉排序树

不知道大家有没有这个感觉就是别人的代码和你的长的一样但是你的就是跑不对。小编在写一个有关BST树的问题的时候网上copy了个代码，然后就出现了各种问题。所以决定还是自己写。

我们来看给定的树节点的定义

typedef struct BinarySearchTreeNode {
	int value;
	struct BinarySearchTreeNode *left, *right;
	struct BinarySearchTreeNode *parent;
}BinarySearchTreeNode;

我所要完成的二叉排序树是带有Parent域的，这个做法简化了删除时候的问题，但是这却增加了个困难，就是插入的时候这个parent怎么处理呢？
如果你去百度一下，大概率都是没有parent域的这种写法

void BiSortTree::insertBST(BiNode* &bt, DataType key)
{
	if (bt == NULL)
	{
		bt = new BiNode;
		bt->data = key;
		bt->lchild = NULL;
		bt->rchild = NULL;
	}
	else
	{
		if (key < bt->data)
			insertBST(bt->lchild, key);
		else
			insertBST(bt->rchild, key);
	}

}

然后粘贴进去发现后面写不了了。。。
为什么？因为你的parent指针没动，这个parent指针在递归写法怎么动？想了半天才发现要加一个新的参数来表示parent,这造成了更大的困难。
然后就是我接下来说的insert非递归写法。
那么问题来了，这个插入你怎么在非递归中判断是从左子树出来的还是右子树出来的呢？我们需要用个flag标记一下。

BinarySearchTreeNode *insert(BinarySearchTreeNode **Tree, int X ) {
	int flag = 1; // flag == 1 时，表示左树出 flag == 2 时，表示右树出
	if (*Tree == NULL)
	{
		*Tree = (BinarySearchTreeNode*)malloc(sizeof(BinarySearchTreeNode));
		if (*Tree == NULL)
		{
			pererror_function(InsertError);
			return NULL;
		}
		(*Tree)->left = NULL;
		(*Tree)->right = NULL;
		(*Tree)->parent = NULL;
		(*Tree)->value = X;
	}
	else
	{
		BinarySearchTreeNode* p = *Tree;
		BinarySearchTreeNode* pre = NULL;
		while (p)
		{
			if (p->value >= X)
			{
				pre = p;
				p = p->left;
				flag = 1;
			}
			else {
				pre = p;
				p = p->right;
				flag = 2;
			}
		}
		p = (BinarySearchTreeNode*)malloc(sizeof(BinarySearchTreeNode));
		if (*Tree == NULL)
		{
			pererror_function(InsertError);
			return NULL;
		}
		p->left = NULL;
		p->right = NULL;
		p->value = X;
		p->parent = pre;
		if (flag == 1)
		{
			pre->left = p;
		}
		else
		{
			pre->right = p;
		}
	}
	
	return *Tree;
}

这不就轻松解决，然后就是这个BST树的查找和删除
查找基本上都没有啥区别

BinarySearchTreeNode *searchNode(BinarySearchTreeNode *Tree, int X) {
	if (Tree == NULL)
	{
		pererror_function(SearchError);
		return NULL;
	}
	else
	{
		if (X == Tree->value)
			return Tree;
		else if (X < Tree->value)
			return searchNode(Tree->left, X);
		else
			return searchNode(Tree->right, X);
	}
}

然后我们来看二叉排序树删除，树的删除一直是个难点，我们有了插入的基础肯定对于删除也不难。
我们要做两个函数，一个用来搜寻这个要删除值的节点，另一个用来对于节点删除进行判断

bool deleteBST(BinarySearchTreeNode *Tree, int X) {
	BinarySearchTreeNode *p = Tree;
	if (Tree == NULL)
	{
		pererror_function(DeleteError);
		return false;
	}
	else
	{
		if (Tree->value == X)
		{
			deleteNode(Tree);
		}
		else if (X < Tree->value)
		{
			return deleteBST(Tree->left,X);
		}
		else
		{
			return deleteBST(Tree->right,X);
		}
		return true;
	}
}

我们关键看下面这个函数
如果删除节点是叶子节点
如果删除节点只有左孩子节点或者只有右孩子节点
如果删除节点左右孩子节点都有
一共有这三种判断情况

void deleteNode(BinarySearchTreeNode* bt)
{
	BinarySearchTreeNode *p;
	if (bt->left == NULL && bt->right == NULL) //Leaf node
	{
		p = bt;
		if (p->parent->left == p)
		{
			p->parent->left = NULL;
		}
		else
		{
			p->parent->right = NULL;
		}
		free(p);
	}
	else if (bt->right == NULL)  // Only left 
	{
		p = bt;
		bt = bt->left;
		p->parent->left = bt;
		free(p);
		p = NULL;
	}
	else if (bt->left == NULL)
	{
		p = bt;
		bt = bt->right;
		p->parent->right = bt;
		free(p);
		p = NULL;
	}
	else   //左右子树均不为空  ,找到左树中最大的或者右树中最小的替换
	{
		p = bt;
		bt = bt->right;
		while (bt->left != NULL)  //此刻已经找到了右树中最小值 bt
		{
			bt = bt->left;
		}
		p->value = bt->value;
		bt->parent->left = bt->right;
		free(bt);
		bt = NULL;
	}
}

前两种很轻松，具有左右孩子的节点在删除的时候，我们需要用个循环来找个关键值。 当前要删除节点左子树的最大值或者当前节点右子树的最小值，这样才能保证这个BST树是正确的BST树。
当然代码还得自己调试看看结果，慢慢品。
BST销毁和二叉树销毁一样
递归进行销毁就行

void makeEmptyNode(BinarySearchTreeNode **Tree) {
	if (*Tree == NULL)
	{
		return;
	}
	makeEmptyNode(&(*Tree)->left);
	makeEmptyNode(&(*Tree)->right);
	free(*Tree);
	*Tree = NULL;
}