二叉树的先序，中序，后序遍历的非递归算法

关键是栈的运用，以此来模拟递归的过程

[cpp]  view plain copy

1. 1.先序遍历非递归算法  
2. #define maxsize 100  
3. typedef struct  
4. {  
5.     Bitree Elem[maxsize];  
6.     int top;  
7. }SqStack;  
8.   
9. void PreOrderUnrec(Bitree t)  
10. {  
11.     SqStack s;  
12.     StackInit(s);  
13.     p=t;  
14.      
15.     while (p!=null || !StackEmpty(s))  
16.     {  
17.         while (p!=null)             //遍历左子树  
18.         {  
19.             visite(p->data);  
20.             push(s,p);  
21.             p=p->lchild;        
22.         }//endwhile  
23.           
24.         if (!StackEmpty(s))         //通过下一次循环中的内嵌while实现右子树遍历  
25.         {  
26.             p=pop(s);  
27.             p=p->rchild;          
28.         }//endif  
29.                  
30.     }//endwhile  
31.      
32. }//PreOrderUnrec  
33.   
34. 2.中序遍历非递归算法  
35. #define maxsize 100  
36. typedef struct  
37. {  
38.     Bitree Elem[maxsize];  
39.     int top;  
40. }SqStack;  
41.   
42. void InOrderUnrec(Bitree t)  
43. {  
44.     SqStack s;  
45.     StackInit(s);  
46.     p=t;  
47.     while (p!=null || !StackEmpty(s))  
48.     {  
49.         while (p!=null)             //遍历左子树  
50.         {  
51.             push(s,p);  
52.             p=p->lchild;  
53.         }//endwhile  
54.           
55.         if (!StackEmpty(s))  
56.         {  
57.             p=pop(s);  
58.             visite(p->data);        //访问根结点  
59.             p=p->rchild;            //通过下一次循环实现右子树遍历  
60.         }//endif     
61.      
62.     }//endwhile  
63.   
64. }//InOrderUnrec  
65.   
66.   
67. 3.后序遍历非递归算法  
68. #define maxsize 100  
69. typedef enum{L,R} tagtype;  
70. typedef struct  
71. {  
72.     Bitree ptr;  
73.     tagtype tag;  
74. }stacknode;  
75.   
76. typedef struct  
77. {  
78.     stacknode Elem[maxsize];  
79.     int top;  
80. }SqStack;  
81.   
82. void PostOrderUnrec(Bitree t)  
83. {  
84.     SqStack s;  
85.     stacknode x;  
86.     StackInit(s);  
87.     p=t;  
88.      
89.     do  
90.     {  
91.         while (p!=null)        //遍历左子树  
92.         {  
93.             x.ptr = p;  
94.             x.tag = L;         //标记为左子树  
95.             push(s,x);  
96.             p=p->lchild;  
97.         }  
98.      
99.         while (!StackEmpty(s) && s.Elem[s.top].tag==R)    
100.         {  
101.             x = pop(s);  
102.             p = x.ptr;  
103.             visite(p->data);   //tag为R，表示右子树访问完毕，故访问根结点        
104.         }  
105.           
106.         if (!StackEmpty(s))  
107.         {  
108.             s.Elem[s.top].tag =R;     //遍历右子树  
109.             p=s.Elem[s.top].ptr->rchild;          
110.         }     
111.     }while (!StackEmpty(s));  
112. }//PostOrderUnrec  

层次遍历

[cpp]  view plain copy

1. int levelorder_traverse(bitree bt, int (*visit)(elemtype e))  
2. {  
3.     sqqueue     sq;  
4.     bitree      cur;  
5.       
6.     init_queue(&sq);  
7.   
8.     if (bt) {  
9.         in_queue(&sq, bt);  
10.         while (!is_queue_empty(sq)) {  
11.             out_queue(&sq, &cur);  
12.             visit(cur->data);  
13.   
14.             if (cur->lchild)  
15.                 in_queue(&sq, cur->lchild);  
16.             if (cur->rchild)  
17.                 in_queue(&sq, cur->rchild);  
18.         }  
19.     }  
20.     return OK;  
21. }