二叉树的前序、中序、后续遍历方法

前段时间找工作，网投了很多互联网公司，中途碰了很多壁，后来每每面试一家回来就加班加点补习基础，其中滋味相信很多人都有经历。

对工作3年内的社招要求必不可少的是基本功的考验。这次有个工作年限比我稍长的同事去参加国内某互联网巨头公司面试。

笔试试卷总共就4道编程题，其中有一道就是分别实现二叉树的前序、中序和后序遍历（非递归实现）。

如果平时没有经常练习基本算法，在面试时间有限的条件很难完全准确无误地写出来。我觉得有必要自己实现一遍，因为如果拿给我，一时间也是手足无措。

网上很多关于二叉树遍历实现的代码，总结一下，前序和中序遍历都相对简单，网上的答案也大体相同。

但对于后序遍历，网上流行的一种是需要构造一个新的结构体，新结构体内包含了一个对该节点访问次数的成员。

我个人是比较排斥这种做法，这里给出了一种不需要借助新结构体来实现二叉树后序遍历的代码供参考，如下：

节点结构

点击(此处)折叠或打开

1. typedef struct BinTree {
   
2.     int val;
   
3.     struct BinTree *left;
   
4.     struct BinTree *right;
   
5. } bintree_t;

前序遍历：

点击(此处)折叠或打开

1. void preOrder(bintree_t *root)
   
2. {
   
3.     bintree_t *p;
   
4.     stack<bintree_t *> s;
   
5. 
   
6.     if (root == NULL) {
   
7.         return;
   
8.     }
   
9. 
   
10.     p = root;
    
11.     while (p != NULL || !s.empty()) {
    
12.         
    
13.         while (p != NULL) {
    
14.             printf("%d ", p->val);
    
15.             s.push(p);
    
16.             p = p->left;
    
17.         }
    
18. 
    
19.         if (!s.empty()) {
    
20.             p = s.top();
    
21.             s.pop();
    
22.             p = p->right;
    
23.         }
    
24.     }
    
25. }

中序遍历：

点击(此处)折叠或打开

1. void inOrder(bintree_t *root)
   
2. {
   
3.     bintree_t *p;
   
4.     stack <bintree_t *> s;
   
5. 
   
6.     if (root == NULL) {
   
7.         return;
   
8.     }
   
9. 
   
10.     p = root;
    
11.     while (p != NULL || !s.empty()) {
    
12. 
    
13.         while (p != NULL) {
    
14.             s.push(p);
    
15.             p = p->left;
    
16.         }
    
17. 
    
18.         if (!s.empty()) {
    
19.             p = s.top();
    
20.             s.pop();
    
21.             printf("%d ", p->val);
    
22.             p = p->right;
    
23.         }
    
24.     }
    
25. }

后序遍历：

点击(此处)折叠或打开

1. void push_leaf(stack<bintree_t *> &s, bintree_t *root)
   
2. {
   
3.     bintree_t *p, *tmp;
   
4. 
   
5.     p = root;
   
6.     while (p != NULL) {
   
7.         s.push(p);
   
8.         tmp = p;
   
9.         p = p->left;
   
10.         if (p == NULL) {
    
11.             p = tmp->right;
    
12.         }
    
13.     }
    
14. }
    
15. 
    
16. bintree_t *pop_leaf(stack <bintree_t *> &s)
    
17. {
    
18.     bintree_t *top, *top2;
    
19. 
    
20.     while (!s.empty()) {
    
21. 
    
22.         top = s.top();
    
23.         printf("%d ", top->val);
    
24.         s.pop();
    
25.         if (s.empty()) {
    
26. 
    
27.             return NULL;
    
28.         }
    
29. 
    
30.         top2 = s.top();
    
31.         if (top2->left == top
    
32.                 && top2->right != NULL) {
    
33.             return top2->right;
    
34.         }
    
35.     }
    
36. }
    
37. 
    
38. void postOrder(bintree_t *root)
    
39. {
    
40.     stack<bintree_t *> s;
    
41.     bintree_t *p;
    
42. 
    
43.     if (root == NULL) {
    
44.         printf("invalid...\n");
    
45.         return;
    
46.     }
    
47. 
    
48.     p = root;
    
49.     while (p != NULL) {
    
50.         push_leaf(s, p);
    
51.         p = pop_leaf(s);
    
52.     }
    
53. }

已知前序和中序，构建二叉树

点击(此处)折叠或打开

1. bintree_t *rebuildTree(int *pa, int *ia, int len)
   
2. {
   
3.     int i;
   
4.     bintree_t *proot = NULL;
   
5.     
   
6.     if (pa == NULL || ia == NULL || len <= 0) {
   
7.         return NULL;
   
8.     }
   
9. 
   
10.     proot = new bintree_t();
    
11.     proot->val = pa[0];
    
12.     proot->left = proot->right = NULL;
    
13. 
    
14.     printf("val = %d len = %d\n", pa[0], len);
    
15.     i = 0;
    
16.     while ((i < len) && (pa[0] != ia[i])) {
    
17.         i++;
    
18.     }
    
19. 
    
20.     if (i >= len) {
    
21.         printf("i = %d len = %d, invalid input!!\n", i, len);
    
22.         exit(0);
    
23.     }
    
24. 
    
25.     if (i > 0) {
    
26.         proot->left = rebuildTree(pa + 1, ia, i);
    
27.     }
    
28. 
    
29.     if (i < len - 1) {
    
30.         proot->right = rebuildTree(pa + i + 1, ia + i + 1, len - (i + 1));
    
31.     }
    
32. 
    
33.     return proot;
    
34. }

点击(此处)折叠或打开

1. #include <stdlib.h>
   
2. #include <stdio.h>
   
3. #include <unistd.h>
   
4. #include <stack>
   
5. #include <exception>
   
6. 
   
7. using namespace std;
   
8. 
   
9. int main(int argc, char *argv[])
   
10. {
    
11.     bintree_t *root = NULL;
    
12.     
    
13.     //int pa[] = {1, 2, 4, 7, 3, 5, 6, 8};
    
14.     //int ia[] = {4, 7, 2, 1, 5, 3, 8, 6};
    
15. 
    
16.     //int pa[] = {1, 3, 6, 10, 13, 15, 7, 8, 12, 14, 16, 17, 20, 21, 22, 25, 26, 30, 36, 42, 40};
    
17.     //int ia[] = {13, 10, 15, 6, 3, 7, 12, 8, 14, 1, 20, 17, 21, 25, 22, 26, 16, 36, 42, 30, 40};
    
18.     int pa[] = {1, 2, 3};
    
19.     int ia[] = {2, 3, 1};
    
20.     
    
21.     root = rebuildTree(pa, ia, sizeof(pa) / sizeof(int));
    
22. 
    
23.     printf("\nPreOrder: ");
    
24.     preOrder(root);
    
25.     printf("\n");
    
26.     printf("\nInOrder: ");
    
27.     inOrder(root);
    
28.     printf("\n");
    
29. 
    
30.     printf("\nPostOrder: ");
    
31.     postOrder(root);
    
32.     printf("\n");
    
33.     
    
34.     return 0;
    
35. }