中序线索二叉树正向，反向遍历

C++语言: Codee#23233

001 #include <stdio.h>
002 #include <malloc.h>
003 #define MaxSize 100
004 typedef char ElemType;
005 typedef struct node
006 {
007     ElemType data;
008     int ltag, rtag;     /*增加的线索标记*/
009     struct node *lchild;
010     struct node *rchild;
011 } TBTNode;
012 void CreateTBTNode(TBTNode * &b, char *str)
013 {
014     TBTNode *St[MaxSize], *p = NULL;
015     int top = -1, k, j = 0;
016     char ch;
017     b = NULL;                /*建立的二叉树初始时为空*/
018     ch = str[j];
019     while (ch != '\0')    /*str未扫描完时循环*/
020     {
021         switch(ch)
022         {
023         case '(':
024             top++;
025             St[top] = p;
026             k = 1;
027             break;        /*为左结点*/
028         case ')':
029             top--;
030             break;
031         case ',':
032             k = 2;
033             break;                          /*为右结点*/
034         default:
035             p = (TBTNode *)malloc(sizeof(TBTNode));
036             p->data = ch;
037             p->lchild = p->rchild = NULL;
038             if (b == NULL)                    /**p为二叉树的根结点*/
039                 b = p;
040             else                              /*已建立二叉树根结点*/
041             {
042                 switch(k)
043                 {
044                 case 1:
045                     St[top]->lchild = p;
046                     break;
047                 case 2:
048                     St[top]->rchild = p;
049                     break;
050                 }
051             }
052         }
053         j++;
054         ch = str[j];
055     }
056 }
057 void DispTBTNode(TBTNode *b)
058 {
059     if (b != NULL)
060     {
061         printf("%c", b->data);
062         if (b->lchild != NULL || b->rchild != NULL)
063         {
064             printf("(");
065             DispTBTNode(b->lchild);
066             if (b->rchild != NULL) printf(",");
067             DispTBTNode(b->rchild);
068             printf(")");
069         }
070     }
071 }
072 TBTNode *pre;                        /*全局变量*/
073 void Thread(TBTNode *&p)
074 {
075     if (p != NULL)
076     {
077         Thread(p->lchild);            /*左子树线索化*/
078         if (p->lchild == NULL)        /*前驱线索*/
079         {
080             p->lchild = pre;            /*建立当前结点的前驱线索*/
081             p->ltag = 1;
082         }
083         else p->ltag = 0;
084         if (pre->rchild == NULL)        /*后继线索*/
085         {
086             pre->rchild = p;             /*建立前驱结点的后继线索*/
087             pre->rtag = 1;
088         }
089         else pre->rtag = 0;
090         pre = p;
091         Thread(p->rchild);          /*右子树线索化*/
092     }
093 }
094 TBTNode *CreaThread(TBTNode *b)     /*中序线索化二叉树*/
095 {
096     TBTNode *root;
097     root = (TBTNode *)malloc(sizeof(TBTNode)); /*创建根结点*/
098     root->ltag = 0;
099     root->rtag = 1;
100     root->rchild = b;
101     if (b == NULL)              /*空二叉树*/
102         root->lchild = root;
103     else
104     {
105         root->lchild = b;
106         pre = root;                 /*pre是*p的前驱结点,供加线索用*/
107         Thread(b);               /*中序遍历线索化二叉树*/
108         pre->rchild = root;        /*最后处理,加入指向根结点的线索*/
109         pre->rtag = 1;
110         root->rchild = pre;        /*根结点右线索化*/
111     }
112     return root;
113 }
114 TBTNode* firstnode(TBTNode* p)
115 {
116     while(p->ltag == 0)
117         p = p->lchild;
118     return p;
119 }
120 TBTNode* nextnode(TBTNode* p)
121 {
122     if(p->rtag == 0)
123         return firstnode(p->rchild);
124     else
125         return p->rchild;
126 }
127 void inorder(TBTNode* root)
128 {
129     for(TBTNode* p = firstnode(root); p!=root; p = nextnode(p))
130         printf("%c ", p->data);
131 }
132
133 TBTNode* lastnode(TBTNode* p)
134 {
135     while(p->rtag == 0)
136         p = p->rchild;
137     return p;
138 }
139 TBTNode* prenode(TBTNode* p)
140 {
141     if(p->ltag == 0)
142         return lastnode(p->lchild);
143     else
144         return p->lchild;
145 }
146 void inorder_reverse(TBTNode* root)
147 {
148     for(TBTNode* p = lastnode(root); p != root; p = prenode(p))
149         printf("%c ", p->data);
150 }
151
152 int main()
153 {
154     TBTNode *b, *tb;
155     CreateTBTNode(b, "A(B(D(,G)),C(E,F))");
156     printf(" 二叉树:");
157     DispTBTNode(b);
158     printf("\n");
159     tb = CreaThread(b);
160     printf(" 线索中序序列:");
161     inorder(tb);
162     printf("\n中序自最后节点反向遍历:\n");
163     inorder_reverse(tb);
164     printf("\n");

165 }