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

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 }

转载于:https://www.cnblogs.com/invisible/archive/2011/10/15/2213696.html