第十四周 项目一 二叉排序树

问题及代码：

[cpp]  view plain  copy

 

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