二叉树Morris Traversal

常见的二叉树遍历有递归和栈循环两种方式，其实还有另一种更为巧妙的遍历方式Morris Traversal。

Morris Traversal的空间复杂度为O（1），时间复杂度为O（n）

我们知道，在深度搜索遍历的过程中，之所以要用递归或者是用非递归的栈方式，都是因为其他的方式没法记录当前节点的parent,而如果在每个节点的结构里面加个parent 分量显然是不现实的，那么Morris是怎么解决这一问题的呢？好吧，他用得很巧妙，实际上是用叶子节点的空指针来记录当前节点的位置，然后一旦遍历到了叶子节点，发现叶子节点的右指针指向的是当前节点，那么就认为以当前节点的左子树已经遍历完成。

以inorder为例，初始化当前节点为root，它的遍历规则如下：

• 如果当前节点为空，程序退出。
• 如果当前节点非空，
  • 如果当前节点的左儿子为空，那么输出当前节点，当前节点重置为当前节点的右儿子。
  • 如果当前节点的左儿子非空，找到当前节点左子树的最右叶子节点（此时最右节点的右儿子有两种情况，一种是指向当前节点，一种是为空,你也许感到奇怪，右节点的右儿子怎么可能非空，注意，这里的最右叶子节点只带的是原树中的最右叶子节点。），若其最右叶子节点为空，令其指向当前节点，将当前节点重置为其左儿子，若其最右节点指向当前节点，输出当前节点，将当前节点重置为当前节点的右儿子,并恢复树结构，即将最右节点的右节点再次设置为NULL

morris 中序遍历

[cpp]  view plain  copy

1. void bst_morris_inorder(struct bst_node *root)  
2. {  
3.     struct bst_node *p = root, *tmp;  
4.   
5.     while (p) {  
6.         if (p->left == NULL) {  
7.             printf("%d ", p->key);  
8.             p = p->right;  
9.         }  
10.         else {  
11.             tmp = p->left;  
12.             while (tmp->right != NULL && tmp->right != p)  
13.                 tmp = tmp->right;  
14.             if (tmp->right == NULL) {  
15.                 tmp->right = p;  
16.                 p = p->left;  
17.             }  
18.             else {  
19.                 printf("%d ", p->key);  
20.                 tmp->right = NULL;  
21.                 p = p->right;  
22.             }  
23.         }  
24.     }  
25. }  

代码相当简单，局部变量也只需要两个。以下简单讲述其实现方式。

morris traversal 原理很简单，利用所有叶子结点的right 指针，指向其后继结点，组成一个环，在第二次遍历到这个结点时，由于其左子树已经遍历完了，则访问该结点

如下图为morris 的一个示例

morris 前序遍历

[cpp]  view plain  copy

1. void bst_morris_preorder(struct bst_node *root)  
2. {  
3.     struct bst_node *p = root, *tmp;  
4.   
5.     while (p) {  
6.         if (p->left == NULL) {  
7.             printf("%d ", p->key);  
8.             p = p->right;  
9.         }  
10.         else {  
11.             tmp = p->left;  
12.             while (tmp->right != NULL && tmp->right != p)  
13.                 tmp = tmp->right;  
14.             if (tmp->right == NULL) {  
15.                 printf("%d ", p->key);                  
16.                 tmp->right = p;  
17.                 p = p->left;  
18.             }  
19.             else {  
20.                 tmp->right = NULL;  
21.                 p = p->right;  
22.             }  
23.         }  
24.     }  
25. }  

比较简单，只要注意访问结点的顺序即可

morris 后序遍历

[cpp]  view plain  copy

1. static void bst_morris_reverse(struct bst_node *node, struct bst_node *last)  
2. {  
3.     struct bst_node *p = node, *x, *y;  
4.     if (p == last) {  
5.         printf("%d ", last->key);  
6.         return;  
7.     }  
8.   
9.     /* change right to parent pointer */  
10.     x = p->right;  
11.     for (;;) {  
12.         if (x == last) {  
13.             x->right = p;  
14.             break;  
15.         }  
16.         y = x->right;  
17.         x->right = p;  
18.         p = x;  
19.         x = y;  
20.     }  
21.   
22.     /* visit each */  
23.     x = last;  
24.     for (;;) {  
25.         printf("%d ", x->key);  
26.         if (x == node)  
27.             break;  
28.         x = x->right;  
29.     }   
30.   
31.     /* revert right pointer */  
32.     p = last;  
33.     x = last->right;  
34.     for (;;) {  
35.         if (x == node) {  
36.             x->right = p;  
37.             break;  
38.         }  
39.         y = x->right;  
40.         x->right = p;  
41.         p = x;  
42.         x = y;  
43.     }  
44. }  
45.   
46.   
47. void bst_morris_postorder(struct bst_node *root)  
48. {  
49.     struct bst_node dummy;  
50.     struct bst_node *p, *tmp;  
51.   
52.     dummy.left = root;  
53.     dummy.right = NULL;  
54.     p = &dummy;  
55.   
56.     while (p) {  
57.         if (p->left == NULL) {  
58.             p = p->right;  
59.         }  
60.         else {  
61.             tmp = p->left;  
62.             while (tmp->right != NULL && tmp->right != p)  
63.                 tmp = tmp->right;  
64.             if (tmp->right == NULL) {  
65.                 tmp->right = p;  
66.                 p = p->left;  
67.             }  
68.             else {  
69.                 bst_morris_reverse(p->left, tmp);  
70.                 tmp->right = NULL;  
71.                 p = p->right;  
72.             }  
73.         }  
74.     }  
75. }  

后序遍历比较复杂，它的思路是利用中序遍历，所以首先产生了一个假的根结点，其左子树为原来的二叉树，从假的根结点开始中序遍历

它和中序遍历有所不同，在发现当前结点左子树为空时，不访问此结点(后序遍历需要保证访问完右子树后才能访问根结点)，直接访问右子树。

第二次遍历到某个结点时，将该结点左子树的最右路径反序输出即可，对应函数为bst_morris_reverse