BST（二叉查找树）

https://songlee24.github.io/2015/01/13/binary-search-tree/

二叉查找树（BST）

发表于 2015-01-13   |   分类于 Basic-算法与数据结构   |  

二叉查找树（Binary Search Tree）又叫二叉排序树（Binary Sort Tree），它是一种数据结构，支持多种动态集合操作，如 Search、Insert、Delete、Minimum 和 Maximum 等。

二叉查找树要么是一棵空树，要么是一棵具有如下性质的非空二叉树：

  1. 若左子树非空，则左子树上的所有结点的关键字值均小于根结点的关键字值。

  2. 若右子树非空，则右子树上的所有结点的关键字值均大于根结点的关键字值。

  3. 左、右子树本身也分别是一棵二叉查找树（二叉排序树）。

可以看出，二叉查找树是一个递归的数据结构，且对二叉查找树进行中序遍历，可以得到一个递增的有序序列。

首先，我们来定义一下 BST 的结点结构体，结点中除了 key 域，还包含域 left, right 和 parent，它们分别指向结点的左儿子、右儿子和父节点：

1
2
3
4
5
6
7
 
typedef struct Node 
{
	int key;
	Node* left;
	Node* right;
	Node* parent;
} *BSTree;

 

一、BST的插入与构造

二叉查找树作为一种动态结构，其特点是树的结构通常不是一次生成的，而是在查找过程中，当树中不存在结点的关键字等于给定值时再进行插入。

由于二叉查找树是递归定义的，插入结点的过程是：若原二叉查找树为空，则直接插入；否则，若关键字 k 小于根结点关键字，则插入到左子树中，若关键字 k 大于根结点关键字，则插入到右子树中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
/**
 * 插入：将关键字k插入到二叉查找树
 */
int BST_Insert(BSTree &T, int k, Node* parent=NULL)
{
	if(T == NULL)
	{
		T = (BSTree)malloc(sizeof(Node));
		T->key = k;
		T->left = NULL;
		T->right = NULL;
		T->parent = parent;
		return 1;  // 返回1表示成功
	}
	else if(k == T->key)
		return 0;  // 树中存在相同关键字
	else if(k < T->key)
		return BST_Insert(T->left, k, T);
	else
		return BST_Insert(T->right, k, T);
}

 

构造一棵二叉查找树就是依次输入数据元素，并将它们插入到二叉排序树中的适当位置。具体过程是：每读入一个元素，就建立一个新结点；若二叉查找树为空，则新结点作为根结点；若二叉查找树非空，则将新结点的值与根结点的值比较，如果小于根结点的值，则插入到左子树中，否则插入到右子树中。

1
2
3
4
5
6
7
8
9
 
/**
 * 构造：用数组arr[]创建二叉查找树
 */
void Create_BST(BSTree &T, int arr[], int n)
{
	T = NULL;  // 初始时为空树
	for(int i=0; i<n; ++i)
		BST_Insert(T, arr[i]);
}

 

注意，插入的新结点一定是某个叶结点。另外，插入操作既可以递归实现，也可以使用非递归（迭代）实现。通常来说非递归的效率会更高。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
/**
 * 非递归插入：将关键字k插入到二叉查找树
 */
int BST_Insert_NonRecur(BSTree &T, int k)
{
	Node* pre = NULL;  // 记录上一个结点
	Node* t = T;
	while(t != NULL)
	{
		pre = t;
		if(k < t->key)
			t = t->left;
		else if(k > t->key)
			t = t->right;
		else
			return 0;
	}

	Node* node = (Node*)malloc(sizeof(Node));
	node->key = k;
	node->left = NULL;
	node->right = NULL;
	node->parent = pre;

	if(pre == NULL)
		T = node;
	else
	{
		if(k < pre->key)
			pre->left = node;
		else
			pre->right = node;
	}
	return 1;
}

 

二、BST的查找

对于二叉查找树，最常见的操作就是查找树中的某个关键字。除了Search操作外，二叉查找树还能支持如 Minimum（最小值）、Maximum（最大值）、Predecessor（前驱）、Successor（后继）等查询。对于高度为 h 的树，这些操作都可以在 Θ(h) 时间内完成。

1. 查找

BST 的查找是从根结点开始，若二叉树非空，将给定值与根结点的关键字比较，若相等，则查找成功；若不等，则当给定值小于根结点关键字时，在根结点的左子树中查找，否则在根结点的右子树中查找。显然，这是一个递归的过程。

1
2
3
4
5
6
7
8
9
10
11
12
 
/**
 * 递归查找：返回指向包含关键字k的结点的指针
 */
Node* BST_Search(BSTree T, int k)
{
	if(T == NULL || k == T->key)
		return T;
	if(k < T->key)
		return BST_Search(T->left, k);
	else
		return BST_Search(T->right, k);
}

 

也可以使用非递归的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
/**
 * 非递归查找：返回指向包含关键字k的结点的指针
 */
Node* BST_Search_NonRecur(BSTree T, int k)
{
	while(T != NULL && k != T->key)
	{
		if(k < T->key)
			T = T->left;
		else
			T = T->right;
	}
	return T;
}

 

2. 最大值与最小值

由二叉查找树的性质可知，最左下结点即为关键字最小的结点，最右下结点即为关键字最大的结点。此过程无需比较，只需要沿着最左和最右的路径查找下去，直到遇到 NULL 为止。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
/**
 * 最小值：查找二叉查找树中关键字最小的结点
 */
Node* BST_Minimum(BSTree T)
{
	while(T->left != NULL)
		T = T->left;
	return T;
}

/**
 * 最大值：查找二叉查找树中关键字最大的结点
 */
Node* BST_Maximum(BSTree T)
{
	while(T->right != NULL)
		T = T->right;
	return T;
}

 

3. 前驱与后继

给定一个二叉查找树的结点，求出它在中序遍历中的前驱与后继。如果所有的关键字均不相同，则某结点 x 的后继是：

  • 若结点 x 的右子树不为空，则 x 的后继就是它的右子树中关键字值最小的结点；

  • 若结点 x 的右子树为空，为了找到其后继，从结点 x 开始向上查找，直到遇到一个祖先结点 y，它的左儿子也是结点 x 的祖先，则结点 y 就是结点 x 的后继。如下图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
/**
 * 后继：查找给定结点在中序遍历中的后继结点
 */
Node* BST_Successor(Node* node)
{
	if(node->right != NULL)
		return BST_Minimum(node->right);
	Node* p = node->parent;
	while(p!=NULL && p->right == node)
	{
		node = p;
		p = p->parent;
	}
	return p;
}

求前驱（predecessor）的过程对称，对于某个结点 x ，它的前驱是：

  • 若结点 x 的左子树不为空，则 x 的前驱是它的左子树中关键字值最大的结点；

  • 若结点 x 的左子树为空，为了找到其前驱，从结点 x 开始向上查找，直到遇到一个祖先结点 y，它的右儿子也是结点 x 的祖先，则结点 y 就是结点 x 的前驱。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
/**
 * 前驱：查找给定结点在中序遍历中的前驱结点
 */
Node* BST_Predecessor(Node* node)
{
	if(node->left != NULL)
		return BST_Maximum(node->left);
	Node* p = node->parent;
	while(p!=NULL && p->left == node)
	{
		node = p;
		p = p->parent;
	}
	return p;
}

之所以在这里讨论如何求中序序列的后继，主要是为了后面讲删除操作做铺垫。

三、BST的删除

二叉查找树的删除操作是相对复杂一点，它要按 3 种情况来处理：

  • 若被删除结点 z 是叶子结点，则直接删除，不会破坏二叉排序树的性质；

  • 若结点 z 只有左子树或只有右子树，则让 z 的子树成为 z 父结点的子树，替代 z 的位置；

  • 若结点 z 既有左子树，又有右子树，则用 z 的后继（Successor）代替 z，然后从二叉查找树中删除这个后继，这样就转换成了第一或第二种情况。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
void BST_Delete(BSTree &T,Node* z)
{
	if(z->left == NULL && z->right == NULL)
	{
		if(z->parent != NULL)
		{
			if(z->parent->left == z)
				z->parent->left = NULL;
			else
				z->parent->right = NULL;
		}
		else
		{
			T = NULL;  // 只剩一个结点的情况
		}
		free(z);
	}
	else if(z->left != NULL && z->right == NULL)
	{
		z->left->parent = z->parent;
		if(z->parent != NULL)
		{
			if(z->parent->left == z)
				z->parent->left = z->left;
			else
				z->parent->right = z->left;
		}
		else
		{
			T = z->left;  // 删除左斜单支树的根结点
		}
		free(z);
	}
	else if(z->left == NULL && z->right != NULL)
	{
		z->right->parent = z->parent;
		if(z->parent != NULL)
		{
			if(z->parent->left == z)
				z->parent->left = z->right;
			else
				z->parent->right = z->right;
		}
		else
		{
			T = z->right;  // 删除右斜单支树的根结点
		}
		free(z);
	}
	else
	{
		Node* s = BST_Successor(z);
		z->key = s->key;   // s的关键字替换z的关键字
		BST_Delete(T, s);  // 转换为第一或第二种情况
	}
}

对于一个高度为 h 的二叉查找树来说，删除操作和插入操作一样，都可以在 Θ(h) 时间内完成。

四、随机构造的二叉查找树

二叉查找树可以实现任何一种基本的动态集合操作，且各基本操作的运行时间都是 Θ(h)。当树的高度较低时，这些操作执行的较快；但是，当树的高度较高时，性能会变差。比如，如果各元素是按严格增长的顺序插入的，那么构造出来的树就是一个高度为 n-1 的链。 为了尽量减少这种最坏情况的出现，我们可以随机地构造二叉查找树，即随机地将各关键字插入一棵初始为空的树来构造 BST。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
//#include <cstdlib>
//#include <ctime>
/**
 * 随机构造二叉查找树
 */
void Create_BST(BSTree &T, int arr[], int n)
{
	T = NULL;  
	// 随机遍历数组，进行插入操作
	srand(time(NULL));
	for(int i=n-1; i>=0; --i)
	{
		int j = rand() % (i+1);
		BST_Insert(T, arr[j]);
		swap(arr[j], arr[i]);
	}
}

 






附：随机遍历数组

在随机构造二叉查找树时，需要解决 随机遍历数组 的问题，即随机遍历一个数组中的所有元素，既不重复也不遗漏。这里能想到的一种思路是：先随机生成0...n-1之间的一个数，然后与数组最后一个数交换，然后再随机生成0...n-2之间的一个数，与数组倒数第二个数交换，直到整个数组遍历结束。显然这个算法的时间复杂度是 O(n)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
#include <iostream>
#include <cstdlib>  // srand rand
#include <ctime>    // time
using namespace std;

void swap(int &a, int &b)  
{  
	int tmp = a;  
	a = b;  
	b = tmp;  
}

/**
 * 随机遍历数组
 */
void Traverse_Random(int arr[], int n)
{
	srand(time(NULL));
	for(int i=n-1; i>=0; --i)
	{
		int j = rand() % (i+1);
		cout << arr[j] << " ";   // 输出
		swap(arr[j], arr[i]);
	}
}

int main() 
{
	int arr[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
	Traverse_Random(arr, 9);
	getchar();
	return 0;
}

 



（全文完）

posted @ 2019-05-27 20:51  rebeca8  阅读(262)  评论(0)  编辑  收藏  举报