第十周项目一 3

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

学习心得：