第十四周项目1-（3）验证二叉排序树相关算法

1. /*  
2. * Copyright (c)2016,烟台大学计算机与控制工程学院  
3. * All rights reserved.  
4. * 文件名称：项目1-3.cbp  
5. * 作    者：陈晓琳  
6. * 完成日期：2016年12月10日  
7. * 版 本 号：v1.0  
8.   
9. * 问题描述：验证二叉排序树相关算法  
10.   
11. * 输入描述：无  
12. * 程序输出：测试数据  
13. */     

代码：

[cpp]  view plain  copy

 

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

运行结果：

知识点总结：

二叉排序树的应用。