一步两步学算法之操作二叉树

  1 #include "stdio.h"
  2 #include "stdlib.h"
  3 #define QUEUE_MAXSIZE 50
  4 
  5 typedef char DATA;
  6 typedef struct ChainTree
  7 {
  8     DATA data;
  9     struct ChainTree *left;
 10     struct ChainTree *right;
 11 }ChainBinTree;
 12 void oper(ChainBinTree *p)
 13 {
 14     printf("%c",p->data);
 15     return;
 16 }
 17 ChainBinTree *BinTreeInit(ChainBinTree *node)  //初始化二叉树 
 18 {
 19         if(node!=NULL)
 20             return node;
 21         else 
 22             return NULL;    
 23 }
 24 
 25 int BinTreeAddNode(ChainBinTree *bt,ChainBinTree *node,int n)
 26                     //bt为父节点，node为子节点，n=1添加左子树，n=2添加右子树 
 27 {
 28     if(bt==NULL)    
 29     {
 30         printf("父节点不存在，请先设置父节点！\n");
 31         return 0;
 32     }
 33     switch(n)
 34     {
 35         case 1:
 36             if(bt->left)
 37             {
 38                 printf("左子树不为空！\n");
 39                 return 0;
 40             }
 41             else
 42                 bt->left=node;
 43             break;
 44         case 2:
 45             if(bt->right)
 46             {
 47                 printf("右子树不为空！\n");
 48                 return 0;
 49             }
 50             else
 51                 bt->right=node;
 52             break;
 53         default:
 54             printf("参数错误！\n");
 55             return 0;
 56     }
 57     return 1;
 58 }
 59 
 60 ChainBinTree *BinTreeLeft(ChainBinTree *bt)  //返回左子树 
 61 {
 62     if(bt)
 63         return bt->left;
 64     else 
 65         return NULL;
 66 }
 67 ChainBinTree *BinTreeRight(ChainBinTree *bt)  //返回右子树 
 68 {
 69     if(bt)
 70         return bt->right;
 71     else 
 72         return NULL;
 73 }
 74 
 75 int BinTreeIsEmpty(ChainBinTree *bt)
 76 {
 77     if(bt)
 78         return 0;
 79     else 
 80         return 1;
 81 }
 82 int BinTreeDepth(ChainBinTree *bt)        //求二叉树深度 
 83 {
 84     int dep1,dep2;
 85     if(bt==NULL)
 86         return 0;
 87     else
 88     {
 89         dep1=BinTreeDepth(bt->left);
 90         dep2=BinTreeDepth(bt->right);
 91         if(dep1>dep2)
 92             return dep1+1;
 93         else 
 94             return dep2+1;
 95     }             
 96 }
 97 
 98 ChainBinTree *BinTreeFind(ChainBinTree *bt,DATA data)
 99 {
100     ChainBinTree *p;
101     if(bt==NULL)
102          return NULL;
103     else
104     {
105         if(bt->data==data)
106             return bt;
107         else
108         {
109             if(p=BinTreeFind(bt->left,data))
110                 return p;
111             else if(p=BinTreeFind(bt->right,data))
112                 return p;
113             else    
114                 return NULL;    
115         }    
116     }
117 }
118 void BinTreeClear(ChainBinTree *bt)
119 {
120     if(bt)
121     {
122         BinTreeClear(bt->left);
123         BinTreeClear(bt->right);
124         free(bt);
125         bt=NULL;
126     }
127     return ;
128 }
129 void BinTree_DLR(ChainBinTree *bt,void (*oper)(ChainBinTree *p))
130 {
131     if(bt)
132     {
133         oper(bt);
134         BinTree_DLR(bt->left,oper);
135         BinTree_DLR(bt->right,oper);
136     }
137     return;
138 }
139 void BinTree_LDR(ChainBinTree *bt,void (*oper)(ChainBinTree *p))
140 {
141     if(bt)
142     {
143         
144         BinTree_LDR(bt->left,oper);
145         oper(bt);
146         BinTree_LDR(bt->right,oper);
147     }
148     return;
149 }
150 void BinTree_LRD(ChainBinTree *bt,void (*oper)(ChainBinTree *p))
151 {
152     if(bt)
153     {
154         
155         BinTree_LRD(bt->left,oper);
156         BinTree_LRD(bt->right,oper);
157         oper(bt);
158         
159     }
160     return;
161 }
162 
163 void BinTree_Level(ChainBinTree *bt,void (*oper)(ChainBinTree *p))
164 {
165     ChainBinTree *p;
166     ChainBinTree *q[QUEUE_MAXSIZE];
167     int head=0,tail=0;
168     if(bt)
169     {
170         tail=(tail+1)%QUEUE_MAXSIZE;
171         q[tail]=bt;
172     }
173     while(head!=tail)
174     {
175         head=(head+1)%QUEUE_MAXSIZE;
176         p=q[head];
177         oper(p);
178         if(p->left!=NULL)
179         {
180             tail=(tail+1)%QUEUE_MAXSIZE;
181             q[tail]=p->left;
182         }
183         if(p->right!=NULL)
184         {
185             tail=(tail+1)%QUEUE_MAXSIZE;
186             q[tail]=p->right;
187         }
188     }
189     return;
190 }
191 
192 ChainBinTree *InitRoot()
193 {
194     ChainBinTree *node;
195     if(node=(ChainBinTree*)malloc(sizeof(ChainBinTree)))
196     {
197         printf("\n输入根节点数据：");
198         scanf("%s",&node->data);
199         node->left=NULL;
200         node->right=NULL;
201         return node; 
202     }
203     return NULL;
204 }
205 void AddNode(ChainBinTree *bt)
206 {
207     ChainBinTree *node,*parent;
208     DATA data;
209     char select;
210     if(node=(ChainBinTree*)malloc(sizeof(ChainBinTree)))
211     {
212         printf("\n输入二叉树节点数据：");
213         fflush(stdin);
214         scanf("%s",&node->data);
215         node->left=NULL;
216         node->right=NULL;
217         printf("请输入父节点数据：");
218         fflush(stdin);
219         scanf("%s",&data);
220         parent=BinTreeFind(bt,data); 
221         if(!parent)
222         {
223             printf("未找到父节点！\n");
224             free(node);
225             return ;
226             
227         }
228         printf("1.添加到左子树\n2.添加到右子树\n");
229         do{
230             select=getchar();
231             select-=‘0‘;
232             if(select==1||select==2)
233                 BinTreeAddNode(parent,node,select);
234         }while(select!=1&&select!=2);
235     }
236     return ;
237 }
238 int main()
239 {
240     ChainBinTree *root=NULL;
241     char select;
242     void(*oper1)(ChainBinTree*);
243     oper1=oper;
244     do
245     {
246         printf("\n1.设置二叉树根元素        2.添加二叉树节点\n");
247         printf("3.先序遍历            4.中序遍历\n");
248         printf("5.后序遍历            6.按层遍历\n");
249         printf("7.二叉树深度            0.退出\n");    
250         
251         select=getchar();
252         if(select==‘\n‘){
253             select=getchar();
254         }
255         switch(select)
256         {
257             case ‘1‘:
258                 root=InitRoot();
259                 break;
260             case ‘2‘:
261                 AddNode(root);
262                 break;
263             case ‘3‘:
264                 printf("\n先序遍历的结果:");
265                 BinTree_DLR(root,oper1);
266                 printf("\n");
267                 break;
268             case ‘4‘:
269                 printf("\n中序遍历的结果:");
270                 BinTree_LDR(root,oper1);
271                 printf("\n");
272                 break;
273             case ‘5‘:
274                 printf("\n后序遍历的结果:");
275                 BinTree_LRD(root,oper1);
276                 printf("\n");
277                 break;
278             case ‘6‘:
279                 printf("\n按层遍历的结果:");
280                 BinTree_Level(root,oper1);
281                 printf("\n");
282                 break;
283             case ‘7‘:
284                 printf("\n二叉树的深度为：%d\n",BinTreeDepth(root));
285                 break;
286             case ‘0‘:
287                 break;     
288         }
289     }while(select!=‘0‘);
290     BinTreeClear(root);
291     root=NULL;
292     return 0;
293 }