二叉树神级遍历算法——Morris遍历(C++版)

题目：

设计一个算法实现二叉树的三种遍历(前序遍历 中序遍历 后序遍历)。

要求时间复杂度为O(n) 空间复杂度为O(1)。

 

思路：

空间复杂度O(1)的要求很严格。常规的递归实现是显然不能满足要求的[其空间复杂度是树的深度O(h) ]。本篇文章介绍著名的Morris遍历，该方法利用了二叉树结点中大量指向null的指针。

常规的栈结构遍历方式，遍历到某个节点之后并不能回到上层的结点，这是由二叉树本身的结构所限制的，每个结点并没有指向父节点的指针，因此需要使用栈来完成回到上层结点的步骤。

Morris遍历避免了使用栈结构，让下层有指向上层的指针，但并不是所有的下层结点都有指向上层的指针([这些指针也称为空闲指针])。

空闲指针的分配规则如下：

1. 当前子树的头结点为head，空闲指针由head的左子树中最右结点的右指针指向head结点。对head的左子树重复该步骤1，直到遍历至某个结点没有左子树，将该结点记    为node。进入步骤2。

2. 从node结点开始通过每个结点的右指针进行移动，并打印结点的值。

  假设遍历到的当前结点为curNode，做如下判断：

curNode结点的左子树中最右结点(记为lastRNode)是否指向curNode。

A. 是 让lastRNode结点的右指针指向null，打印curNode的值。接着通过curNode的右指针遍历下一个结点，重复步骤2。

B. 否 将curNode为头结点的子树重复步骤1。

 

下面举例说明上述步骤(先以中序遍历为例)，二叉树结构如下图所示：

遍历至结点1 发现其没有左子树 记为Node。

curNode : 1 打印1

curNode : 2 满足A 空闲指针由1的右指针指向2 将该空闲指针取消掉 打印2。通过2的右指针遍历到3。

curNode : 3 满足B 进行步骤1 最终打印3。

通过空闲指针遍历至4。

curNode : 4 满足A 空闲指针由3的右指针指向4 将该空闲指针取消掉 打印4。通过4的右指针遍历到6。

至此 左子树和根结点遍历完毕。

curNode : 6 满足B 进行步骤1 之后二叉树变为右图。

遍历至结点5 其没有左子树 记为Node。

curNode : 5 满足B 进行步骤1 最终打印5。

通过空闲指针遍历至6。

curNode : 6 满足A 空闲指针由5的右指针指向6 将该空闲指针取消掉 打印6。

通过6的右指针遍历到7。

curNode : 7 满足B 进行步骤1 最终打印7。

3. 步骤2最终移动到null结点 整个过程结束。

 

总结：

打印某个结点时，一定是在步骤2开始移动的过程中。

步骤2最开始从子树最左结点开始，在通过右指针移动过程中，只有以下两种移动方式：

①移动到某个结点的右子树【此时 左子树和根结点必定已经打印结束】

②移动到某个上层结点(即通过空闲指针移动)【此时 该上层结点的左子树整体打印完毕 开始处理根结点】

 

Morris先序遍历只需要将打印顺序稍微调整一下(调整至步骤1中打印)。

Morris后序遍历同样是需要将打印顺序稍微调整一下，即：逆序打印(不能使用额外的数据结构)所有结点的左子树右边界，在满足步骤2中情况A时打印。

注：

二叉树结点定义如下：
typedef int dataType;

struct Node

{

dataType val;

struct Node *left;

struct Node *right;

Node(dataType _val):

val(_val), left(NULL), right(NULL){}

};

常规的二叉树遍历方式采用栈实现，比较容易实现，下面直接给出代码。

/*************************Morris遍历二叉树*************************/

 

[cpp] view plain copy

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. typedef int dataType;  
6. struct Node  
7. {  
8.     dataType val;  
9.     struct Node *left;  
10.     struct Node *right;  
11.   
12.     Node(dataType _val):  
13.         val(_val), left(NULL), right(NULL){}  
14. };  
15.   
16. // Morris中序遍历 (左 -> 根 -> 右)  
17. void MorrisInOrderTraverse(Node *head)  
18. {  
19.     if (head == NULL)  
20.     {  
21.         return;  
22.     }  
23.   
24.     Node *p1 = head;  
25.     Node *p2 = NULL;  
26.   
27.     while (p1 != NULL)  
28.     {  
29.         p2 = p1->left;  
30.         if (p2 != NULL)  
31.         {  
32.             while(p2->right != NULL && p2->right != p1)  
33.             {  
34.                 p2 = p2->right;  
35.             }  
36.             if (p2->right == NULL)  
37.             {  
38.                 p2->right = p1;      // 空闲指针  
39.                 p1 = p1->left;  
40.                 continue;  
41.             }  
42.             else  
43.             {  
44.                 p2->right = NULL;  
45.             }  
46.         }  
47.         cout<<p1->val<<" ";  
48.         p1 = p1->right;  
49.     }  
50. }  
51.   
52. // Morris前序遍历 (根 -> 左 -> 右)  
53. void MorrisPreOrderTraverse(Node *head)  
54. {  
55.     if (head == NULL)  
56.     {  
57.         return;  
58.     }  
59.   
60.     Node *p1 = head;  
61.     Node *p2 = NULL;  
62.   
63.     while (p1 != NULL)  
64.     {  
65.         p2 = p1->left;  
66.         if (p2 != NULL)  
67.         {  
68.             while(p2->right != NULL && p2->right != p1)  
69.             {  
70.                 p2 = p2->right;  
71.             }  
72.             if (p2->right == NULL)  
73.             {  
74.                 p2->right = p1;      // 空闲指针  
75.                 cout<<p1->val<<" ";  // 打印结点值的顺序稍微调整  
76.                 p1 = p1->left;  
77.                 continue;  
78.             }  
79.             else  
80.             {  
81.                 p2->right = NULL;  
82.             }  
83.         }  
84.         else  
85.         {  
86.             cout<<p1->val<<" ";  
87.         }  
88.         p1 = p1->right;  
89.     }  
90. }  
91.   
92. // 逆序右边界  
93. Node* reverseEdge(Node *head)  
94. {  
95.     Node *pre = NULL;  
96.     Node *next = NULL;  
97.   
98.     while(head != NULL)  
99.     {  
100.         next = head->right;  
101.         head->right = pre;  
102.         pre = head;  
103.         head = next;  
104.     }  
105.   
106.     return pre;  
107. }  
108.   
109. // 逆序打印左子树右边界  
110. void printEdge(Node *head)  
111. {  
112.     Node *lastNode = reverseEdge(head);  
113.     Node *cur = lastNode;  
114.   
115.     while (cur != NULL)  
116.     {  
117.         cout<<cur->val<<" ";  
118.         cur = cur->right;  
119.     }  
120.     reverseEdge(lastNode);  
121. }  
122.   
123. // Morris后序遍历 (左 -> 右 -> 根)  
124. void MorrisPostOrderTraverse(Node *head)  
125. {  
126.     if (head == NULL)  
127.     {  
128.         return;  
129.     }  
130.   
131.     Node *p1 = head;  
132.     Node *p2 = NULL;  
133.   
134.     while (p1 != NULL)  
135.     {  
136.         p2 = p1->left;  
137.         if (p2 != NULL)  
138.         {  
139.             while(p2->right != NULL && p2->right != p1)  
140.             {  
141.                 p2 = p2->right;  
142.             }  
143.             if (p2->right == NULL)  
144.             {  
145.                 p2->right = p1;      // 空闲指针  
146.                 p1 = p1->left;  
147.                 continue;  
148.             }  
149.             else  
150.             {  
151.                 p2->right = NULL;  
152.                 printEdge(p1->left);  
153.             }  
154.         }  
155.         p1 = p1->right;  
156.     }  
157.     printEdge(head);  
158. }  
159.   
160. void buildBinTree(Node **head)  
161. {  
162.     dataType _val;  
163.     cin>>_val;  
164.   
165.     if (_val == -1)  
166.     {  
167.         *head = NULL;  
168.     }  
169.     else  
170.     {  
171.         *head = (Node*)malloc(sizeof(Node));  
172.         (*head)->val = _val;  
173.         buildBinTree(&(*head)->left);  
174.         buildBinTree(&(*head)->right);  
175.     }  
176. }  
177.   
178. int main(void)  
179. {  
180.     Node *head;  
181.     buildBinTree(&head);  
182.     cout<<"前序遍历序列为:";  
183.     MorrisPreOrderTraverse(head);  
184.     cout<<endl;  
185.   
186.     cout<<"中序遍历序列为:";  
187.     MorrisInOrderTraverse(head);  
188.     cout<<endl;  
189.   
190.     cout<<"后序遍历序列为:";  
191.     MorrisPostOrderTraverse(head);  
192.     cout<<endl;  
193.   
194.     return 0;  
195. }  

/*************************Morris遍历二叉树 END*************************/

输入：

1 2 3 -1 -1 4 -1 -1 5 6 8 -1 -1 -1 7 -1 -1

输出：

致谢：

本篇文章参考自左神新书《程序员代码面试指南：IT名企算法与数据结构题目最优解》，在此表示感谢。