二叉查找树相关算法实现(算法导论12章)

/*
 * copyright@nciaebupt 转载请保留此标记 
 * 查找树（search tree）是一种数据结构，它支持多种集合操作，
 * 包括SEARCH，MINIMUM，MAXIMUM，PREDECESSOR，SUCCESSOR，INSERT和DELETE。
 * 二叉查找树是用二叉树结构来组织的查找树。
 * 它满足这样的性质：每个结点的左子树中所有的元素都小于等于该结点的值，
 * 而该结点同时小于等于它的右子树中的所有元素的值。
 */
#include <iostream>
#include <vector>
using namespace std;

//二叉查找树的节点定义
struct BSTreeNode
{
	int key;
	BSTreeNode * left;
	BSTreeNode * right;
	BSTreeNode * parent;
};
//二叉查找树定义
struct BSTree
{
	BSTreeNode * root;
};
//设置一个哨兵节点
BSTreeNode * NIL = new BSTreeNode;
//二叉查找树的插入
bool Insert(BSTree * T,BSTreeNode * bsnode)
{
	BSTreeNode * x = NIL;//x 一直是y的父节点
	BSTreeNode * y = T->root;//y是移动变量，用来找bsnode的位置。
	//一直向下查找直到 当y到达叶子节点的下一个节点，x为y的父节点
	while(y != NIL)
	{
		x = y;
		if(bsnode->key <= y->key)
		{
			y = y->left;
		}else
		{
			y = y->right;
		}
	}
	if(x == NIL)//当tree为空时
	{
		T->root = bsnode;
		bsnode->parent = NIL;
	}
	else
	{	//根据bsnode的值来决定放在叶子节点的左边还是右边
		if(bsnode->key <= x->key)
		{
			x->left = bsnode;
			bsnode->parent = x;
		}	
		else
		{
			x->right = bsnode;
			bsnode->parent = x;
		}	
	} 
	return true;
}
//二叉查找树的中序遍历
bool InorderTreeWalk(BSTreeNode * x)
{
	if( x != NIL)
	{
		InorderTreeWalk(x->left);
		cout<<x->key<<endl;
		InorderTreeWalk(x->right);
	}
	return true;
}
//二叉查找树的查找
BSTreeNode * BSTreeSearch(BSTreeNode * x,int key)
{
	while(x != NIL && x->key != key)
	{
		if(key <= x->key)
		{
			x = x->left;
		}
		else
		{
			x = x->right;
		}
	}
	return x;	
}
//二叉查找树的最小值
BSTreeNode * BSTreeMin(BSTreeNode * x)
{
	while(x->left != NIL)
	{
		x = x->left;
	}
	return x;
}
//二叉查找树的最大值
BSTreeNode * BSTreeMax(BSTreeNode * x)
{
	while(x->right != NIL)
	{
		x = x->right; 
	}
	return x;
}
//查找某个节点的后继
BSTreeNode * Successor(BSTreeNode * x)
{
	if(x->right != NIL)//如果节点x有右节点，x的后继便是它右子树中的最小元素
	{
		return BSTreeMin(x->right);
	}
	//如果节点x没有右子树，则x的后继便是离它最近的并把它当成左子树部分的祖先
	BSTreeNode * y = x->parent;
	while(y != NIL && x != y->left)
	{
		x = y;
		y = y->parent;
	}
	return y;
}
//查找某个节点的前驱
BSTreeNode * Predecessor(BSTreeNode * x)
{
	if(x->left != NIL)//如果节点x有左节点，x的后继便是它左子树中的最大元素
		return BSTreeMax(x->left);
	//如果节点x没有左子树，则x的后继便是离它最近的并把它当成右子树部分的祖先
	BSTreeNode * y = x->parent;
	while(y != NIL && x != y->right)
	{
		x = y;
		y = y->parent;
	}
	return y;
}
//二叉查找树删除某个节点
BSTreeNode * BSTreeDelete(BSTree * T,BSTreeNode * z)
{
	BSTreeNode * y;
	BSTreeNode * x;
	//确定要删除的节点y，y可能是z，也可能是z的后继
	if(z->left == NIL || z->right == NIL)
		y = z;
	else
		y = Successor(z);
	//确定y的子节点x，x可能为NIL
	if(y->left != NIL)
		x = y->left;
	else
		x = y->right;
	//y只有一个孩子的情况
	if(x != NIL)
		x->parent = y->parent;
	//y没有孩子或者只有一个孩子时，y的父节点与x建立链接	
	if(y->parent == NIL)
		T->root = x;
	else
	{
		if(y->parent->left = y)
			y->parent->left = x;
		else
			y->parent->right = x;
	}
	//y有两个孩子的时候，将z与y的key交换
	if( y != z)
	{
		z->key = y->key;
	}
} 
int main(int argc, char **argv)
{	//15,5,3,12,10,13,6,7,16,20,18,23
	BSTree * T =new BSTree;
	T->root = NIL;
	vector<int> vi;
	vi.push_back(15);
	vi.push_back(5);
	vi.push_back(3);
	vi.push_back(12);
	vi.push_back(10);
	vi.push_back(13);
	vi.push_back(6);
	vi.push_back(7);
	vi.push_back(16);
	vi.push_back(20);
	vi.push_back(18);
	vi.push_back(23);
	for(int i = 0; i < vi.size(); ++i)
	{
		BSTreeNode * bsnode = new BSTreeNode;
		bsnode->key = vi[i];
		bsnode->left = NIL;
		bsnode->right = NIL;
		bsnode->parent = NIL;
		Insert(T,bsnode);
	}
	/*
	//中序遍历二叉查找树
	InorderTreeWalk(T->root);
	*/ 
	/*
	//在二叉查找树中查找关键字为18的node
	BSTreeNode * pkey = BSTreeSearch(T->root,18);
	cout<<pkey<<" "<<pkey->key<<endl;
	*/
	/*
	//查找二叉查找树中的最小值
	BSTreeNode * pmin = BSTreeMin(T->root);
	cout<<pmin<<" "<<pmin->key<<endl;
	*/ 
	/*
	//查找二叉查找树的最大值
	BSTreeNode * pmax = BSTreeMax(T->root);
	cout<<pmax<<" "<<pmax->key<<endl;
	*/
	/*
	//查找关键字13的后继
	BSTreeNode * pkey = BSTreeSearch(T->root,18);
	BSTreeNode * psuc = Successor(pkey);
	cout<<pkey->key<<" "<<psuc->key<<endl;
	*/
	/*
	//查找关键字13的前驱
	BSTreeNode * pkey = BSTreeSearch(T->root,13);
	BSTreeNode * ppre = Predecessor(pkey);
	cout<<pkey->key<<" "<<ppre->key<<endl;
	*/
	//中序遍历二叉查找树,删除元素18后再次遍历二叉查找树
	InorderTreeWalk(T->root);
	BSTreeNode * pz = BSTreeSearch(T->root,18); 
	BSTreeNode * pdel = BSTreeDelete(T,pz);
	InorderTreeWalk(T->root);
	
	return 0;
}