二叉树的遍历

刚才看到了一篇关于层序遍历二叉树的帖子，突然想到了自己数据结构作业中写的二叉树的遍历。现在看来，这些并不难了，当时却是费了很大的劲。

写了四种遍历方法——前中后序和层序，其中前中后序用到了栈，层序用到了队列。

Code:

1. typedef struct node   
2. {   
3.     char data;   
4.     struct node *lchild;   
5.     struct node *rchild;   
6. }BTreeNode;   
7.   
8. /   
9. //先序遍历   
10. /   
11. void PreOrder(BTreeNode *t)   
12. {   
13.     InitStack(&s);   
14.     BTreeNode *p;   
15.     p = t->lchild;   
16.     while(p != NULL || IsEmptyStack())//当前节点为非空或栈非空时循环   
17.     {   
18.         if(p != NULL)//非叶节点输出当前节点，右子树进栈，当前节点指向左子树   
19.         {   
20.             cout << p->data;   
21.             PushStack(p->rchild);   
22.             p = p->lchild;   
23.         }   
24.         else//当前节点为空时弹栈   
25.         {   
26.             p = PopStack();   
27.         }   
28.     }   
29. }   
30. /   
31. //中序遍历   
32. /   
33. void InOrder(BTreeNode *t)   
34. {   
35.     BTreeNode *p;   
36.   
37.     p = t->lchild;   
38.     InitStack(&s);   
39.     while(p!= NULL || IsEmptyStack())//当前节点为非空或栈非空时循环   
40.     {   
41.         if(p != NULL)//当前节点非空是进栈，当前节点指向左子树   
42.         {   
43.             PushStack(p);   
44.             p = p->lchild;   
45.         }   
46.         else{//当前节点为空时弹栈，输出节点信息，当前节点指向左子树   
47.             p = PopStack();   
48.             cout << p->data;   
49.             p = p->rchild;   
50.         }   
51.     }   
52.   
53. }   
54. /   
55. //后序遍历   
56. /   
57. void PostOrder(BTreeNode *t)   
58. {   
59.     BTreeNode *p = NULL, *pr = NULL;   
60.     p = t->lchild;   
61.     InitStack(&s);   
62.     while(p != NULL || IsEmptyStack())//当前节点非空或栈未空是循环   
63.     {   
64.         if(p!= NULL)//若当前节点非空则进栈，当前节点指向左子树   
65.         {   
66.             PushStack(p);   
67.             p = p->lchild;   
68.         }   
69.         else{//当前节点为空时，指向栈顶节点的右子树   
70.             p = s.stack[s.top];   
71.             p = p->rchild;   
72.             if(p == NULL || p == pr)//右子树未空，或右子树已输出，则弹栈，输出当前节点信息   
73.             {   
74.                 p = PopStack();   
75.                 cout << p->data;   
76.                 pr = p;   
77.                 p = NULL;   
78.             }   
79.         }   
80.     }   
81. }   
82. /   
83. //层序遍历   
84. /   
85. void LevelOrder(BTreeNode *t)   
86. {   
87.     BTreeNode *p;   
88.     p = t->lchild;   
89.     InitQuene(&q);   
90.     QueneEn(p);   
91.     while(p != NULL && IsEmptyQuene())//当前节点非空且栈未空是循环   
92.     {   
93.         p = QueneOut();//出队，输出当前节点信息   
94.         cout << p->data;   
95.         if(p->lchild != NULL)//若左子树非空，左子树进栈   
96.             QueneEn(p->lchild);   
97.         if(p->rchild != NULL)//若右子树非空，右子树进栈   
98.             QueneEn(p->rchild);   
99.     }   
100. }