二叉树遍历之morris遍历

我们在遍历树时使用的 递归遍历 或者 迭代遍历，其实都是用到了堆栈来存储，增加了空间复杂度

有没有办法连这个空间都不要额外分配呢？

考虑一棵树：

1. 如果有 N 个节点，那么就有 2N 个指针（分别指向左子节点，右子节点）

2. 每一个节点，其实只有 1 个指针指向他，根节点没有节点指向，那么用到的指针个数：N-1

3. 结合1，2我们可以得知，还有 2N - (N - 1) = N + 1 个指针是空闲的

    比如节点可能有 0，1，2个子节点，对应空闲指针 2，1，0 个

如果我们能够利用这些空闲指针，就可以降低额外的空间复杂度

以前序遍历来看：1，2，4，5，10，11，3，7

以 节点 4 来讲

前缀节点：2

后缀节点：5

节点4 访问 节点5 需要回溯到其父节点 2；

节点10 访问 节点11 需要回溯到其父节点 5；

节点11 访问 节点3 需要回溯到其父节点 1；

当树的深度够大时，回溯的过程会很长，我们期望利用空闲指针，达成这样的效果

这种方式相当于利用空闲指针建立了一个索引，我们称之为 线索二叉树

前序方式的构建方式，称之为 前序线索二叉树，但是还存有一个问题：

        我们方便的知道后缀节点，但是这样不容易知道 前缀节点是多少

后续方式比较复杂，用的最多的构建方式还是 中序线索二叉树

能够方便的得到前缀及后缀节点，我们来看看怎么做到的

其实中序遍历就是对每个节点的垂直投影

我们构建的线索是这样的：

 

前缀节点：当前节点的左子树最右的那个节点 

        比如 节点 1 的前缀节点，左子树 2 的最右节点 = 11

 后缀节点：线索指针指向节点 或者原本右子树遍历到的最左节点

        比如 节点 4 的后缀节点=2，节点 10 的后缀节点=5，节点 11 的后缀节点 = 1

我们在遍历时，构建的线索二叉树会破坏整个树的形态，所以在构建过程中，还会同时删除构建的线索，这样才能还原本来的样子。

中序线索二叉树 的构建过程：

1. 当前根节点如果为 NULL，直接返回

2.找当前节点的左子树的最右节点        // 节点 1

        2.1 找到当前节点的 左子节点        // 节点 2

        2.2 递归 左子节点的 右子节点，直到为NULL        // 节点 11

        2.3 将找到的该最右的子节点的 right 指向当前节点        // 节点 11->right = 节点 1

3. 继续构建，以 2 为 根节点，得到了 节点 4->right = 2

4. 以 2 为根节点的左子树完成，开始处理其右子树，同理，得到了 节点 10->right = 节点 5

5. 最后 节点 1 的整个左子树构建完成，开始处理其右子树

前序遍历：

void preorderMorris(struct TreeNode* cur)
{
	if(cur == NULL)
		return;
		
	struct TreeNode *mostRight = NULL;
	
	while(cur != NULL)
	{
		mostRight = cur->left;
		
		if(mostRight != NULL)
		{
			while(mostRight->right != NULL && mostRight->right != cur)    // 1
			{
				mostRight = mostRight->right;
			}
			
			if(mostRight->right == NULL)        // 2
			{
				mostRight->right = cur;
				printf("val=%d\n", cur->val);
				cur = cur->left;                // 3
				continue;
			}
			else                                // 4
			{
				mostRight->right = NULL;
			}
		}
		else
		{
			printf("val=%d\n", cur->val);	
		}
		
		cur = cur->right;    // 5
	}
}

        1)  最右节点可能已经有构建，所以只有不为空并且不等于当前的根节点时才继续右子节点遍历

        2）找到最右节点，指向当前根节点

        3）继续根节点的余下左子节点构建过程

        4）已经构建好了，我们需要删除该线索，维持原本树的形态。打印节点过程会在此前完成

        5)  继续处理当前节点的右子树

中序遍历：框架不变，改变打印的地方

void inorderMorris(struct TreeNode* cur)
{
	if(cur == NULL)
		return;
		
	struct TreeNode *mostRight = NULL;
	
	while(cur != NULL)
	{
		mostRight = cur->left;
		
		if(mostRight != NULL)
		{
			while(mostRight->right != NULL && mostRight->right != cur)
			{
				mostRight = mostRight->right;
			}
			
			if(mostRight->right == NULL)
			{
				mostRight->right = cur;
				
				cur = cur->left;
				continue;
			}
			else
			{
				mostRight->right = NULL;
				printf("val=%d\n", cur->val);
			}
		}
		else
		{
			printf("val=%d\n", cur->val);	
		}
		
		cur = cur->right;
	}
}

后序遍历：框架不变，不同于前序，中序在构建中打印

一如既往的不走寻常路，我们需要观察下遍历顺序 

1. 前缀节点刚好是左子节点时，打印然后删除索引，比如：4，10

2. 但是 11 不符合这个情况，是 1 的前缀节点，但不是其左子节点（2）

    但是 11，5，2 的打印顺序正好是：以当前节点 1的左子节点开始的链 （2，5，11）的反序

3. 处理完左子树后，右子树节点 7 都不符合 1，2 条件，但是也是翻转即可

我们可以合并1，2的打印都作 翻转 （因为 1 个节点的翻转也是自己）

4. 翻转完成，记得再次翻转，否则树的这个链被反向了

struct TreeNode* reverse(struct TreeNode* head)
{
	struct TreeNode *prev = NULL;
	struct TreeNode *cur, *next;
	
	cur = head;
	while(cur != NULL)
	{
			next = cur->right;
			cur->right = prev;
			prev = cur;
			cur = next;
	}
	
	return prev;
}

void printNode(struct TreeNode* head)
{
	struct TreeNode* tail = reverse(head);
	
	while(tail)
	{
		printf("val=%d\n", tail->val);
		tail = tail->right;
	}
	
	reverse(tail);
}

打印的时间就在删除索引的时刻

void postorderMorris(struct TreeNode* cur)
{
	if(cur == NULL)
		return;
		
	struct TreeNode *root = cur; // last chain	
	struct TreeNode *mostRight = NULL;
	
	while(cur != NULL)
	{
		mostRight = cur->left;
		
		if(mostRight != NULL)
		{
			while(mostRight->right != NULL && mostRight->right != cur)
			{
				mostRight = mostRight->right;
			}
			
			if(mostRight->right == NULL)
			{
				mostRight->right = cur;
				
				cur = cur->left;
				continue;
			}
			else
			{
				mostRight->right = NULL;
				printNode(cur->left);
			}
		}
		
		cur = cur->right;
	}
	
	printNode(root);
}

-------preorder Morris------
val=1
val=2
val=4
val=5
val=10
val=11
val=3
val=7

-------inorder Morris------
val=4
val=2
val=10
val=5
val=11
val=1
val=3
val=7

-------postorder Morris------
val=4
val=10
val=11
val=5
val=2
val=7
val=3
val=1

更多数据结构详解