二叉查找树(二叉排序树)的详细实现，以及随机平衡二叉查找树Treap的分析与应用

这是一篇两年前写的东西，自我感觉还是相当不错的Treap教程。正好期末信息科学技术概论课要求交一个论文，就把这个东西修改了一下交了，顺便也发到这里吧。

随机平衡二叉查找树Treap的分析与应用

1、序

详细实现了二叉查找树的各种操作：插入结点、构造二叉树、删除结点、查找、  查找最大值、查找最小值、查找指定结点的前驱和后继

2、二叉查找树简介

它或者是一棵空树；或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3）左、右子树也分别为二叉排序树

3、二叉查找树的各种操作

此处给出代码，注释非常详细，具体操作请参考代码：

[cpp] view
plaincopy

1. /*************************************************************************
2. 这是一个二叉查找树，实现了以下操作：插入结点、构造二叉树、删除结点、查找、
3. 查找最大值、查找最小值、查找指定结点的前驱和后继。上述所有操作时间复杂度
4. 均为o(h),其中h是树的高度
5. 注释很详细，具体内容就看代码吧
6. *************************************************************************/
7. #include<stdio.h>
8. #include<stdlib.h>
9. //二叉查找树结点描述
10. typedef int KeyType;
11. typedef struct Node
12. {
13. KeyType key;          //关键字
14. struct Node * left;   //左孩子指针
15. struct Node * right;  //右孩子指针
16. struct Node * parent; //指向父节点指针
17. }Node,*PNode;
18. //往二叉查找树中插入结点
19. //插入的话，可能要改变根结点的地址，所以传的是二级指针
20. void inseart(PNode * root,KeyType key)
21. {
22. //初始化插入结点
23. PNode p=(PNode)malloc(sizeof(Node));
24. p->key=key;
25. p->left=p->right=p->parent=NULL;
26. //空树时，直接作为根结点
27. if((*root)==NULL){
28. *root=p;
29. return;
30. }
31. //插入到当前结点（*root）的左孩子
32. if((*root)->left == NULL && (*root)->key > key){
33. p->parent=(*root);
34. (*root)->left=p;
35. return;
36. }
37. //插入到当前结点（*root）的右孩子
38. if((*root)->right == NULL && (*root)->key < key){
39. p->parent=(*root);
40. (*root)->right=p;
41. return;
42. }
43. if((*root)->key > key)
44. inseart(&(*root)->left,key);
45. else if((*root)->key < key)
46. inseart(&(*root)->right,key);
47. else
48. return;
49. }
50. //查找元素,找到返回关键字的结点指针，没找到返回NULL
51. PNode search(PNode root,KeyType key)
52. {
53. if(root == NULL)
54. return NULL;
55. if(key > root->key) //查找右子树
56. return search(root->right,key);
57. else if(key < root->key) //查找左子树
58. return search(root->left,key);
59. else
60. return root;
61. }
62. //查找最小关键字,空树时返回NULL
63. PNode searchMin(PNode root)
64. {
65. if(root == NULL)
66. return NULL;
67. if(root->left == NULL)
68. return root;
69. else  //一直往左孩子找，直到没有左孩子的结点
70. return searchMin(root->left);
71. }
72. //查找最大关键字,空树时返回NULL
73. PNode searchMax(PNode root)
74. {
75. if(root == NULL)
76. return NULL;
77. if(root->right == NULL)
78. return root;
79. else  //一直往右孩子找，直到没有右孩子的结点
80. return searchMax(root->right);
81. }
82. //查找某个结点的前驱
83. PNode searchPredecessor(PNode p)
84. {
85. //空树
86. if(p==NULL)
87. return p;
88. //有左子树、左子树中最大的那个
89. if(p->left)
90. return searchMax(p->left);
91. //无左子树,查找某个结点的右子树遍历完了
92. else{
93. if(p->parent == NULL)
94. return NULL;
95. //向上寻找前驱
96. while(p){
97. if(p->parent->right == p)
98. break;
99. p=p->parent;
100. }
101. return p->parent;
102. }
103. }
104. //查找某个结点的后继
105. PNode searchSuccessor(PNode p)
106. {
107. //空树
108. if(p==NULL)
109. return p;
110. //有右子树、右子树中最小的那个
111. if(p->right)
112. return searchMin(p->right);
113. //无右子树,查找某个结点的左子树遍历完了
114. else{
115. if(p->parent == NULL)
116. return NULL;
117. //向上寻找后继
118. while(p){
119. if(p->parent->left == p)
120. break;
121. p=p->parent;
122. }
123. return p->parent;
124. }
125. }
126. //根据关键字删除某个结点,删除成功返回1,否则返回0
127. //如果把根结点删掉，那么要改变根结点的地址，所以传二级指针
128. int deleteNode(PNode* root,KeyType key)
129. {
130. PNode q;
131. //查找到要删除的结点
132. PNode p=search(*root,key);
133. KeyType temp;    //暂存后继结点的值
134. //没查到此关键字
135. if(!p)
136. return 0;
137. //1.被删结点是叶子结点，直接删除
138. if(p->left == NULL && p->right == NULL){
139. //只有一个元素，删完之后变成一颗空树
140. if(p->parent == NULL){
141. free(p);
142. (*root)=NULL;
143. }else{
144. //删除的结点是父节点的左孩子
145. if(p->parent->left == p)
146. p->parent->left=NULL;
147. else  //删除的结点是父节点的右孩子
148. p->parent->right=NULL;
149. free(p);
150. }
151. }
152. //2.被删结点只有左子树
153. else if(p->left && !(p->right)){
154. p->left->parent=p->parent;
155. //如果删除是父结点，要改变父节点指针
156. if(p->parent == NULL)
157. *root=p->left;
158. //删除的结点是父节点的左孩子
159. else if(p->parent->left == p)
160. p->parent->left=p->left;
161. else //删除的结点是父节点的右孩子
162. p->parent->right=p->left;
163. free(p);
164. }
165. //3.被删结点只有右孩子
166. else if(p->right && !(p->left)){
167. p->right->parent=p->parent;
168. //如果删除是父结点，要改变父节点指针
169. if(p->parent == NULL)
170. *root=p->right;
171. //删除的结点是父节点的左孩子
172. else if(p->parent->left == p)
173. p->parent->left=p->right;
174. else //删除的结点是父节点的右孩子
175. p->parent->right=p->right;
176. free(p);
177. }
178. //4.被删除的结点既有左孩子，又有右孩子
179. //该结点的后继结点肯定无左子树(参考上面查找后继结点函数)
180. //删掉后继结点,后继结点的值代替该结点
181. else{
182. //找到要删除结点的后继
183. q=searchSuccessor(p);
184. temp=q->key;
185. //删除后继结点
186. deleteNode(root,q->key);
187. p->key=temp;
188. }
189. return 1;
190. }
191. //创建一棵二叉查找树
192. void create(PNode* root,KeyType *keyArray,int length)
193. {
194. int i;
195. //逐个结点插入二叉树中
196. for(i=0;i<length;i++)
197. inseart(root,keyArray[i]);
198. }
199. int main(void)
200. {
201. int i;
202. PNode root=NULL;
203. KeyType nodeArray[11]={15,6,18,3,7,17,20,2,4,13,9};
204. create(&root,nodeArray,11);
205. for(i=0;i<2;i++)
206. deleteNode(&root,nodeArray[i]);
207. printf("%d\n",searchPredecessor(root)->key);
208. printf("%d\n",searchSuccessor(root)->key);
209. printf("%d\n",searchMin(root)->key);
210. printf("%d\n",searchMax(root)->key);
211. printf("%d\n",search(root,13)->key);
212. return 0;
213. }

4、附录

参考书籍     《算法导论》