第11周项目1-验证算法（3）中序线索化二叉树的算法验证

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

代码：

[cpp]  view plain  copy

 

1. #include <stdio.h>    
2. #include <malloc.h>    
3.     
4.     
5. #define MaxSize 100    
6. typedef char ElemType;    
7. typedef struct node    
8. {    
9.     ElemType data;    
10.     int ltag,rtag;      //增加的线索标记    
11.     struct node *lchild;    
12.     struct node *rchild;    
13. } TBTNode;    
14.     
15.     
16. void CreateTBTNode(TBTNode * &b,char *str)    
17. {    
18.     TBTNode *St[MaxSize],*p=NULL;    
19.     int top=-1,k,j=0;    
20.     char ch;    
21.     b=NULL;             //建立的二叉树初始时为空    
22.     ch=str[j];    
23.     while (ch!='\0')    //str未扫描完时循环    
24.     {    
25.         switch(ch)    
26.         {    
27.         case '(':    
28.             top++;    
29.             St[top]=p;    
30.             k=1;    
31.             break;      //为左结点    
32.         case ')':    
33.             top--;    
34.             break;    
35.         case ',':    
36.             k=2;    
37.             break;                          //为右结点    
38.         default:    
39.             p=(TBTNode *)malloc(sizeof(TBTNode));    
40.             p->data=ch;    
41.             p->lchild=p->rchild=NULL;    
42.             if (b==NULL)                    //*p为二叉树的根结点    
43.                 b=p;    
44.             else                            //已建立二叉树根结点    
45.             {    
46.                 switch(k)    
47.                 {    
48.                 case 1:    
49.                     St[top]->lchild=p;    
50.                     break;    
51.                 case 2:    
52.                     St[top]->rchild=p;    
53.                     break;    
54.                 }    
55.             }    
56.         }    
57.         j++;    
58.         ch=str[j];    
59.     }    
60. }    
61.     
62.     
63. void DispTBTNode(TBTNode *b)    
64. {    
65.     if (b!=NULL)    
66.     {    
67.         printf("%c",b->data);    
68.         if (b->lchild!=NULL || b->rchild!=NULL)    
69.         {    
70.             printf("(");    
71.             DispTBTNode(b->lchild);    
72.             if (b->rchild!=NULL) printf(",");    
73.             DispTBTNode(b->rchild);    
74.             printf(")");    
75.         }    
76.     }    
77. }    
78.     
79.     
80. TBTNode *pre;                       //全局变量    
81.     
82.     
83. void Thread(TBTNode *&p)    
84. {    
85.     if (p!=NULL)    
86.     {    
87.         Thread(p->lchild);          //左子树线索化    
88.         if (p->lchild==NULL)        //前驱线索    
89.         {    
90.             p->lchild=pre;          //建立当前结点的前驱线索    
91.             p->ltag=1;    
92.         }    
93.         else p->ltag=0;    
94.         if (pre->rchild==NULL)      //后继线索    
95.         {    
96.             pre->rchild=p;          //建立前驱结点的后继线索    
97.             pre->rtag=1;    
98.         }    
99.         else pre->rtag=0;    
100.         pre=p;    
101.         Thread(p->rchild);          //右子树线索化    
102.     }    
103. }    
104.     
105.     
106. TBTNode *CreaThread(TBTNode *b)     //中序线索化二叉树    
107. {    
108.     TBTNode *root;    
109.     root=(TBTNode *)malloc(sizeof(TBTNode));  //创建根结点    
110.     root->ltag=0;    
111.     root->rtag=1;    
112.     root->rchild=b;    
113.     if (b==NULL)                //空二叉树    
114.         root->lchild=root;    
115.     else    
116.     {    
117.         root->lchild=b;    
118.         pre=root;               //pre是*p的前驱结点,供加线索用    
119.         Thread(b);              //中序遍历线索化二叉树    
120.         pre->rchild=root;       //最后处理,加入指向根结点的线索    
121.         pre->rtag=1;    
122.         root->rchild=pre;       //根结点右线索化    
123.     }    
124.     return root;    
125. }    
126.     
127.     
128. void ThInOrder(TBTNode *tb)    
129. {    
130.     TBTNode *p=tb->lchild;      //指向根结点    
131.     while (p!=tb)    
132.     {    
133.         while (p->ltag==0) p=p->lchild;    
134.         printf("%c ",p->data);    
135.         while (p->rtag==1 && p->rchild!=tb)    
136.         {    
137.             p=p->rchild;    
138.             printf("%c ",p->data);    
139.         }    
140.         p=p->rchild;    
141.     }    
142. }    
143.     
144.     
145. int main()    
146. {    
147.     TBTNode *b,*tb;    
148.     CreateTBTNode(b,"A(B(D(,G)),C(E,F))");    
149.     printf(" 二叉树:");    
150.     DispTBTNode(b);    
151.     printf("\n");    
152.     tb=CreaThread(b);    
153.     printf(" 线索中序序列:");    
154.     ThInOrder(tb);    
155.     printf("\n");    
156.     return 0;    
157. }    

运行结果：

知识点总结：

二叉树算法库的应用，实现中序线索化二叉树的算法验证。