《算法导论》学习笔记（3）——二叉搜索树

 二叉搜索树是以一棵二叉树来组织的。在二叉树的基础上，增加了一些限制：

对于任何结点x，其左子树的任何结点都不大于x.key，右子树的任何结点都不小于x.key。

二叉树与二叉堆：

         二者都是基于二叉树来构建的数据结构，但是二者的区别在于：

二叉堆（最大堆）的每个结点的值都大于等于其两个儿子的值，二叉查找树的父亲是小于等于其右孩子的。如下图：

基本操作：

（一）查找：Tree_search

输入参数：指向根结点的指针和要查找的关键字

返回值：如果存在该关键字，则返回关键字所在的结点。否则返回空

         该过程从根结点开始查找，并沿着该树的一条路径向下进行。由于二叉搜索树要求每个结点是有序的，所以该过程十分类似二叉检索。

 

（二）最大最小关键字元素Tree_maximum、Tree_minimum

输入参数：二叉搜索树中的某一结点

返回值：以该指针为根的子树中的最大或最小结点

         该过程也是利用了二叉搜索树的性质，可以快速地定位最大最小值。

 

（三）后继和前驱Tree_successor、Tree_predecessor

输入参数：二叉搜索树中的某一结点

返回值：该结点的前驱结点和后继结点

         后继指比该元素大的下一个元素。如果是右子树非空，就返回右子树中的最左结点。否则就是该结点所有有左孩子的祖先结点中的最底层祖先。

         前驱指比该元素小的下一个元素，其原理跟后继一样。

 

（四）插入Tree_insert

输入参数：要插入的结点、根结点

返回值：空

         根据二叉搜索树的性质，找到该结点应放置的位置。可从根结点依次向下遍历，直到找到该元素适合的位置。

                                    

（五）删除Tree_delete

输入参数：要删除的结点、根结点

返回值：空

         删除的结点需要分一下三种情况考虑：

①左子树、右子树都没有，即叶子结点：直接删除

②左子树、右子树二者有其一：将其子树直接连接在其父结点上

③左子树、右子树二者都有：首先删除其后继，并让后继的父结点成为后继的右子树的父结点，再将后继的值代替要删除结点的值

实现代码如下：

[cpp] view plaincopy

1. #include <iostream>  
2. using namespace std;  
3.   
4. struct Node  
5. {  
6.     int key;  
7.     Node* right; //右孩子  
8.     Node* left; //左孩子  
9.     Node* parent; //父节点  
10. };  
11.   
12.   
13. Node tree_search( Node* x, int k )  
14. {  
15.     if( x == NULL || k == x->key )  
16.         return x;  
17.     if( k < x->key )  
18.         return tree_search(x->left,k);  
19.     else  
20.         return tree_search(x->right,k);  
21. }  
22.   
23. Node tree_maximum( Node* x )  
24. {  
25.     if( x->left == NULL )  
26.         return x;  
27.     else  
28.         return tree_maximum( x->left );  
29. }  
30.   
31. Node tree_minimum( Node* x )  
32. {  
33.     if( x->right == NULL )  
34.         return x;  
35.     else  
36.         return tree_maximum( x->right );  
37. }  
38.   
39. Node tree_successor( Node* x )  
40. {  
41.     if( x->right != NULL )  
42.         return tree_minimum(x->right);  
43.     Node* y = x->parent;  
44.     while( y!=NULL && x==y->right )  
45.     {  
46.         x = y;  
47.         y = y->parent;  
48.     }  
49.     return y;  
50. }  
51.   
52. void tree_insert( Node* z, Node* root )  
53. {  
54.     Node* x = root;  
55.     Node* y = NULL;  
56.     while( x != NULL )  
57.     {  
58.         y = x;  
59.         if( z->key < x->key )  
60.             x = x->left;  
61.         else  
62.             x = x->right;  
63.     }  
64.     z->parent = y;  
65.     if( y == NULL )  
66.         root = z;  
67.     else if( z->key < y->key )  
68.         y->left = z;  
69.     else  
70.         y->right = z;  
71. }  
72.   
73. void Tree_delete( Node *z, Node* root )  
74. {  
75.     Node* x,* y;  
76.     //若z最多只有一个孩子，就直接删除z  
77.     if( z->left == NULL && z->right == NULL )  
78.         y = z;  
79.     else  
80.         y = tree_successor( z );  
81.     //x表示实际要删除的结点的孩子  
82.     if( y->left != NULL )  
83.         x = y->left;  
84.     else  
85.         x = y->right;  
86.     //修改指针，删去结点  
87.     if( x != NULL )  
88.         x->parent = y->parent;  
89.     //实际要删除的结点是根结点  
90.     if( y->parent == NULL )  
91.         root = x;  
92.     else if( y == y->parent->left )  
93.         y->parent->left = x;  
94.     else  
95.         y->parent->right = x;  
96.   
97.     if( y != z )  
98.     {  
99.         z->key = y->key;  
100.     }  
101. }