【第十四周项目1 - 验证算法之二叉排序树】

问题及代码：

[cpp]  view plain  copy

 

1. /* 
2.  * Copyright (c) 2016, 烟台大学计算机与控制工程学院 
3.  * All rights reserved. 
4.  * 文件名称：Cube007.cpp 
5.  * 作    者：杨俊杰
6.  * 完成日期：2016年12月8日 
7.  * 
8.  * 问题描述：验证二叉排序树相关算法 
9.  * 输入描述：无 
10.  * 输出描述：结果 
11.  */  
12.   
13. #include <stdio.h>  
14. #include <malloc.h>  
15. typedef int KeyType;  
16. typedef char InfoType[10];  
17. typedef struct node                 //记录类型  
18. {  
19.     KeyType key;                    //关键字项  
20.     InfoType data;                  //其他数据域  
21.     struct node *lchild,*rchild;    //左右孩子指针  
22. } BSTNode;  
23.   
24. //在p所指向的二叉排序树中，插入值为k的节点  
25. int InsertBST(BSTNode *&p,KeyType k)  
26. {  
27.     if (p==NULL)                        //原树为空, 新插入的记录为根结点  
28.     {  
29.         p=(BSTNode *)malloc(sizeof(BSTNode));  
30.         p->key=k;  
31.         p->lchild=p->rchild=NULL;  
32.         return 1;  
33.     }  
34.     else if (k==p->key)                 //树中存在相同关键字的结点,返回0  
35.         return 0;  
36.     else if (k<p->key)  
37.         return InsertBST(p->lchild,k);  //插入到*p的左子树中  
38.     else  
39.         return InsertBST(p->rchild,k);  //插入到*p的右子树中  
40. }  
41.   
42. //由有n个元素的数组A，创建一个二叉排序树  
43. BSTNode *CreateBST(KeyType A[],int n)   //返回BST树根结点指针  
44. {  
45.     BSTNode *bt=NULL;                   //初始时bt为空树  
46.     int i=0;  
47.     while (i<n)  
48.     {  
49.         InsertBST(bt,A[i]);             //将关键字A[i]插入二叉排序树T中  
50.         i++;  
51.     }  
52.     return bt;                          //返回建立的二叉排序树的根指针  
53. }  
54.   
55. //输出一棵排序二叉树  
56. void DispBST(BSTNode *bt)  
57. {  
58.     if (bt!=NULL)  
59.     {  
60.         printf("%d",bt->key);  
61.         if (bt->lchild!=NULL || bt->rchild!=NULL)  
62.         {  
63.             printf("(");                        //有孩子结点时才输出(  
64.             DispBST(bt->lchild);                //递归处理左子树  
65.             if (bt->rchild!=NULL) printf(",");  //有右孩子结点时才输出,  
66.             DispBST(bt->rchild);                //递归处理右子树  
67.             printf(")");                        //有孩子结点时才输出)  
68.         }  
69.     }  
70. }  
71.   
72. //在bt指向的节点为根的排序二叉树中，查找值为k的节点。找不到返回NULL  
73. BSTNode *SearchBST(BSTNode *bt,KeyType k)  
74. {  
75.     if (bt==NULL || bt->key==k)         //递归终结条件  
76.         return bt;  
77.     if (k<bt->key)  
78.         return SearchBST(bt->lchild,k);  //在左子树中递归查找  
79.     else  
80.         return SearchBST(bt->rchild,k);  //在右子树中递归查找  
81. }  
82.   
83. //二叉排序树中查找的非递归算法  
84. BSTNode *SearchBST1(BSTNode *bt,KeyType k)  
85. {  
86.     while (bt!=NULL)  
87.     {  
88.         if (k==bt->key)  
89.             return bt;  
90.         else if (k<bt->key)  
91.             bt=bt->lchild;  
92.         else  
93.             bt=bt->rchild;  
94.     }  
95.     return NULL;  
96. }  
97.   
98. void Delete1(BSTNode *p,BSTNode *&r)  //当被删*p结点有左右子树时的删除过程  
99. {  
100.     BSTNode *q;  
101.     if (r->rchild!=NULL)  
102.         Delete1(p,r->rchild);   //递归找最右下结点  
103.     else                        //找到了最右下结点*r  
104.     {  
105.         p->key=r->key;          //将*r的关键字值赋给*p  
106.         q=r;  
107.         r=r->lchild;            //直接将其左子树的根结点放在被删结点的位置上  
108.         free(q);                //释放原*r的空间  
109.     }  
110. }  
111.   
112. void Delete(BSTNode *&p)   //从二叉排序树中删除*p结点  
113. {  
114.     BSTNode *q;  
115.     if (p->rchild==NULL)        //*p结点没有右子树的情况  
116.     {  
117.         q=p;  
118.         p=p->lchild;            //直接将其右子树的根结点放在被删结点的位置上  
119.         free(q);  
120.     }  
121.     else if (p->lchild==NULL)   //*p结点没有左子树的情况  
122.     {  
123.         q=p;  
124.         p=p->rchild;            //将*p结点的右子树作为双亲结点的相应子树  
125.         free(q);  
126.     }  
127.     else Delete1(p,p->lchild);  //*p结点既没有左子树又没有右子树的情况  
128. }  
129.   
130. int DeleteBST(BSTNode *&bt, KeyType k)  //在bt中删除关键字为k的结点  
131. {  
132.     if (bt==NULL)  
133.         return 0;               //空树删除失败  
134.     else  
135.     {  
136.         if (k<bt->key)  
137.             return DeleteBST(bt->lchild,k); //递归在左子树中删除为k的结点  
138.         else if (k>bt->key)  
139.             return DeleteBST(bt->rchild,k); //递归在右子树中删除为k的结点  
140.         else  
141.         {  
142.             Delete(bt);     //调用Delete(bt)函数删除*bt结点  
143.             return 1;  
144.         }  
145.     }  
146. }  
147. int main()  
148. {  
149.     BSTNode *bt;  
150.     int n=12,x=46;  
151.     KeyType a[]= {25,18,46,2,53,39,32,4,74,67,60,11};  
152.     bt=CreateBST(a,n);  
153.     printf("BST:");  
154.     DispBST(bt);  
155.     printf("\n");  
156.     printf("删除%d结点\n",x);  
157.     if (SearchBST(bt,x)!=NULL)  
158.     {  
159.         DeleteBST(bt,x);  
160.         printf("BST:");  
161.         DispBST(bt);  
162.         printf("\n");  
163.     }  
164.     return 0;  
165.   
166. }  

运行结果：