算法导论-第12章-二叉搜索（查找）树

一、概念

1.定义与性质

（1）设x为二叉查找树中的一个结点，其左子树中的关键字最大不超过x.key，其右子树中的关键字最小不低于x.key。

（2）二叉查找树上执行的基本操作的时间与树的高度成正比。

结构如下图所示：

2.结构

（1）结点结构：

关键字key

卫星数据data

分别指向父、左右孩子的指针p, left, right

3.在二叉查找树上的操作

查找一个关键字：SEARCH(x, k)

求最小关键字：MINIMUM(x)

求最大关键字：MAXIMUM(x)

求前驱：PREDECESSOR(x)

求后继：SUCCESSOR(x)

插入一个结点：INSERT(T, z)

删除一个结点：DELETE(z)

4.二叉查找树的应用

1.遍历：中序遍历（结果是从小到大）、先序遍历、后序遍历

2.查找：查找包含某个关键字的结点，查找关键字最大或最小的结点、查找某个结点的前驱或后继

 二叉搜索树的这些操作（搜索，mini，max，前驱，后继，插入，删除）都可以在O(h)时间内完成。（h是数的高度）

遍历（前，中，后）需要O(n)时间完成，n是结点个数。

二、代码

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

struct BST_Node
{
public:
	int key;//关键字
	int data;//卫星数据
	BST_Node *left;//左孩子
	BST_Node *right;//右孩子
	BST_Node *p;//父结点

	BST_Node(int x):key(x),data(x),left(NULL),right(NULL),p(NULL){}
};

//二叉查找树的结构
class BST_Tree
{
public:
	BST_Node *root;
	BST_Tree():root(NULL){}	
public:
	//二叉查找树中序遍历
	void Inorder_Tree_Walk(BST_Node *x);
	//查询二叉查找树
	BST_Node *Tree_Search(BST_Node *x, int k);
	BST_Node *Iterative_Tree_Search(BST_Node *x, int k);
	BST_Node *Iterative_Tree_Minimum(BST_Node *x);
	BST_Node *Iterative_Tree_Maximum(BST_Node *x);
	BST_Node *Tree_Successor(BST_Node *x);
	//插入和删除
	void Iterative_Tree_Insert(BST_Node *z);
	BST_Node *Tree_Delete(BST_Node *z);
};
/*************12.1 二叉查找树****************************************************************/
//递归的中序遍历
void BST_Tree::Inorder_Tree_Walk(BST_Node *x)
{
	if(x != NULL)
	{
		//中序遍历当前结点的左子树
		Inorder_Tree_Walk(x->left);
		//访问当前结点
		cout<<x->key<<endl;
		//中序遍历当前结点的右子树
		Inorder_Tree_Walk(x->right);
	}
}
/********12.2 查询二叉查找树****************************************************************/
//递归地查询二叉查找树
BST_Node *BST_Tree::Tree_Search(BST_Node *x, int k)
{
	//找到叶子结点了还没找到，或当前结点是所查找的结点
	if(x == NULL || k == x->key)
		return x;
	//所查找的结点位于当前结点的左子树
	if(k < x->key)
		return Tree_Search(x->left, k);
	//所查找的结点位于当前结点的左子树
	else
		return Tree_Search(x->right, k);
}
//非递归的查询二叉查找树
BST_Node *BST_Tree::Iterative_Tree_Search(BST_Node *x, int k)
{
	//不是叶子结点且不是所查找的结点
	while(x != NULL && k != x->key)
	{
		//所查找的结点位于当前结点的左子树
		if(k < x->key)
			x = x->left;
		//所查找的结点位于当前结点的右子树
		else
			x = x->right;
	}
	return x;
}
//非递归找最小值
BST_Node *BST_Tree::Iterative_Tree_Minimum(BST_Node *x)
{
	//只要有比当前结点小的结点
	while(x->left != NULL)
		x = x->left;
	return x;
}
//非递归找最大值
BST_Node *Iterative_Tree_Maximum(BST_Node *x)
{
	//只要有比当前结点小的结点
	while(x->right != NULL)
		x = x->right;
	return x;
}
//查找中序遍历下x结点的后继，后继是大于key[x]的最小的结点
BST_Node *BST_Tree::Tree_Successor(BST_Node *x)
{
	//如果有右孩子
	if(x->right != NULL)
		//右子树中的最小值
		return Iterative_Tree_Minimum(x->right);
	//如果x的右子树为空且x有后继y，那么y是x的最底层祖先结点，且y的左孩子也是x的祖先
	BST_Node *y = x->p;
	<span style="white-space:pre">	</span>//找到x的最底层祖先，则为x的后继（直到x的祖先为左结点为止，即为x的后继）
		while(y != NULL && x == y->right)
		{
			x = y;
			y = y->p;
		}
		return y;
}
/*********12.3插入和删除**********************************************************/
//二叉查找树的插入，非递归，插入是把某结点z插入到叶结点下面，先找到要插入的位置
void BST_Tree::Iterative_Tree_Insert(BST_Node *z)
{
	//找到要插入的位置
	BST_Node *x = root, *y = NULL;
	//若x为空,x是要插入的位置，x的父是z->p
	while(x != NULL)
	{
		<span style="white-space:pre">		</span>//循环结束后找到y为叶节点，为z的父节点
			y = x;
		if(z->key == x->key)
		{
			cout<<"error:exist"<<endl;
			return;
		}
		if(z->key < x->key)
			x = x->left;
		else
			x = x->right;
	}
	//修改指针，注意树为空的情况
	z->p = y;
	if(y == NULL)
		root = z;
	else if(z->key < y->key)
		y->left = z;
	else y->right = z;
}
//递归的二叉查找树的插入操作，分三种情况  
void BST_Tree::Tree_Insert(BST_Node *x, BST_Node *z)  
{  
	//已经存在  
	if(z->key == x->key)  
	{  
		cout<<"error:exist"<<endl;  
		return;  
	}  
	//插入到x的左子树中  
	else if(z->key < x->key)  
	{  
		//x没有左子树，到了叶结点，递归结束条件
		if(x->left == NULL)  
		{  
			//修改指针，插入操作  
			x->left = z;  
			z->p = x;  
			return;  
		}  
		//x有左子树  
		else  
			//对x的左子树执行插入操作  
			Tree_Insert(x->left, z);  
	}  
	//插入到x的右子树中，与上面类似  
	else if(z->key > x->key)  
	{  
		if(x->right == NULL)  
		{  
			x->right = z;  
			z->p = x;  
			return;
		}  
		else  
			Tree_Insert(x->right, z);  
	}  
} 
//二叉查找树的删除，实际删除的不一定是z，可能是z的后继
//然后把z的值改为实际删除结点的值
//1、z无孩子，则直接删除，修改父节点
//2、z只有一个孩子，用孩子替换z即可
//3、z有两个孩子，用z的后继代替z，还需变动其他结点
//智商不够用啊，书上的方法看懂了，这下面的方法没看懂
BST_Node *BST_Tree::Tree_Delete(BST_Node *z)
{
	BST_Node *x, *y;
	//若z最多只有一个孩子，实际删除的结点是z
	if(z->left == NULL || z->right == NULL)
		y = z;
	//若z有两个孩子，实际删除的结点是z的后继
	else
		y = Tree_Successor(z);
	//用x表示"实际要删除的结点"的孩子（最多一个孩子）
	if(y->left != NULL)
		x = y->left;
	else
		x = y->right;
	//修改指针，以删去结点
	if(x != NULL)//若"实际要删除的结点"没有孩子
		x->p = y->p;
	if(y->p == NULL)//若"实际要删除的结点"是根结点
		root = x;
	else if(y == y->p->left)
		y->p->left = x;
	else y->p->right = x;
	//"若初阶要删除的结点"不是"待删除的结点"，则内容替代
	if(y != z)
	{
		z->key = y->key;
		z->data = y->data;
	}
	return y;
}