二叉树前序/中序/后序遍历的非递归实现（含Morris中序遍历）

前言

树的遍历是一种重要的运算，其非递归实现是使用栈来模拟递归的过程，通过不断将节点及其左子节点压入栈中，出栈相当于回到原先的节点（回溯），在不同时机对栈内元素进行输出（也可以是某种操作），即可实现前中后序遍历。

前序遍历

即按照根-左-右的顺序遍历，入栈的同时对节点进行输出（即先输出根节点再输出左子树），出栈时由于当前节点以及左子节点已经在入栈过程中输出了，因此将当前节点出栈并转而对右子树的节点进行入栈以及后续输出。

void PreOrder(Tree h) {
	stack<Tree> st;
	while (h != nullptr || !st.empty()) {
		while (h != nullptr) {
			st.push(h);
			cout << h->val << ' ';
			h = h->left;
		}
		if (!st.empty()) {
			h = st.top()->right;
			st.pop();
		}
	}
}

中序遍历

即按照左-根-右的顺序遍历，入栈时不进行输出，出栈时当前节点的左子树已完成遍历，因此将当前节点输出并出栈，然后对右子树的节点进行入栈以及后续输出。

void InOrder(Tree h) {
	stack<Tree> st;
	while (h != nullptr || !st.empty()) {
		while (h != nullptr) {
			st.push(h);
			h = h->left;
		}
		if (!st.empty()) {
			cout << st.top()->val << ' ';
			h = st.top()->right;
			st.pop();
		}
	}
}

后序遍历

即按照左-右-根的顺序遍历，入栈时不进行输出，出栈时当前节点的左子树已完成遍历，因为要先输出右子树，根节点最后输出，所以这个时候要进行判断，如果当前节点没有右子树或者其右子树已经输出，则可以输出当前节点并出栈，反之则不出栈（出栈意味着当前节点已结束操作），而先遍历其右子树。
判断右子树是否已经遍历过可以通过记录前一个输出的节点，而前一个节点是其右子树（如果有）的最后遍历的那个节点——右子节点。

void PostOrder(Tree h) {
	stack<Tree> st;
	Tree pre = nullptr; //记录前一个节点
	while (h != nullptr || !st.empty()) {
		while (h != nullptr) {
			st.push(h);
			h = h->left;
		}
		if (!st.empty()) {
			Tree tmp = st.top();
			if (tmp->right == nullptr || tmp->right == pre) { //无右节点或右节点已访问过
				cout << tmp->val << ' ';
				st.pop();
				pre = tmp;
			}
			else {
				h = tmp->right;
			}
		}
	}
}

Morris中序遍历

Morris中序遍历不需要借助栈，其空间复杂度为O(1)，在中序遍历的时候，先遍历左子树，然后遍历当前节点，最后遍历右子树。要实现遍历完左子树可以再回到当前节点，可以考虑修改它的前驱节点（遍历中的前一个节点）的 right 指针。当前节点的前驱节点的 right 指针可能本来就指向当前节点（前驱是当前节点的父节点），也可能是当前节点左子树最右下的节点。如果是后者，我们希望遍历完这个前驱节点之后再回到当前节点，可以将它的 right 指针指向当前节点。

Morris 中序遍历的一个重要步骤就是寻找当前节点的前驱节点，并且 Morris 中序遍历寻找下一个点始终是通过转移到 right 指针指向的位置来完成的。

·如果当前节点没有左子树，则遍历这个点，然后跳转到当前节点的右子树。

·如果当前节点有左子树，那么它的前驱节点一定在左子树上，我们可以在左子树上一直向右行走，找到当前点的前驱节点。
(1)如果前驱节点没有右子树，就将前驱节点的 right 指针指向当前节点。这一步是为了在遍历完前驱节点 后能找到前驱节点的后继，也就是当前节点。
(2)如果前驱节点的右子树为当前节点，说明前驱节点已经被遍历过并被修改了 right 指针，这个时候我们 重新将前驱的右孩子设置为空，遍历当前的点，然后跳转到当前节点的右子树。

void MorrisInorder(Tree h) {
	Tree cur = h, pre = nullptr;
	while (cur) {
		if (cur->left == nullptr) {
			cout << cur->val << ' ';
			cur = cur->right;
			continue;
		}
		pre = cur->left;
		while (pre->right != nullptr && pre->right != cur) {
			pre = pre->right;
		}
		if (pre->right == nullptr) {
			pre->right = cur;
			cur = cur->left;
		}
		else {
			pre->right = nullptr;
			cout << cur->val << ' ';
			cur = cur->right;
		}
	}
}

完整代码及用例

#include<iostream>
#include<stack>
using namespace std;

typedef struct TreeNode* Tree;
struct TreeNode{
	int val;
	Tree left;
	Tree right;
	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

void BuildTree(Tree h); //建树
void DeleteTree(Tree h); //删树
void PreOrder(Tree h); //前序遍历
void InOrder(Tree h); //中序遍历
void PostOrder(Tree h); //后序遍历
void MorrisInorder(Tree h); //Morris中序遍历

int main() {
	Tree head = new TreeNode(1);
	BuildTree(head);
	PreOrder(head);
	cout << endl;
	InOrder(head);
	cout << endl;
	PostOrder(head);
	cout << endl;
	MorrisInorder(head);
	DeleteTree(head);
	return 0;
}

void BuildTree(Tree h) {
	Tree t2 = new TreeNode(2);
	Tree t3 = new TreeNode(3);
	Tree t4 = new TreeNode(4);
	Tree t5 = new TreeNode(5);
	Tree t6 = new TreeNode(6);
	Tree t7 = new TreeNode(7);
	Tree t8 = new TreeNode(8);
	h->left = t2;
	t2->left = t3;
	t3->left = t4;
	t2->right = t5;
	h->right = t6;
	t6->left = t7;
	t7->right = t8;
}

void DeleteTree(Tree h) {
	if (h == nullptr)
		return;
	DeleteTree(h->left);
	DeleteTree(h->right);
	delete h;
}

void PreOrder(Tree h) {
	stack<Tree> st;
	while (h != nullptr || !st.empty()) {
		while (h != nullptr) {
			st.push(h);
			cout << h->val << ' ';
			h = h->left;
		}
		if (!st.empty()) {
			h = st.top()->right;
			st.pop();
		}
	}
}
void InOrder(Tree h) {
	stack<Tree> st;
	while (h != nullptr || !st.empty()) {
		while (h != nullptr) {
			st.push(h);
			h = h->left;
		}
		if (!st.empty()) {
			cout << st.top()->val << ' ';
			h = st.top()->right;
			st.pop();
		}
	}
}
void PostOrder(Tree h) {
	stack<Tree> st;
	Tree pre = nullptr; //记录前一个节点
	while (h != nullptr || !st.empty()) {
		while (h != nullptr) {
			st.push(h);
			h = h->left;
		}
		if (!st.empty()) {
			Tree tmp = st.top();
			if (tmp->right == nullptr || tmp->right == pre) { //无右节点或右节点已访问过
				cout << tmp->val << ' ';
				st.pop();
				pre = tmp;
			}
			else {
				h = tmp->right;
			}
		}
	}
}

void MorrisInorder(Tree h) {
	Tree cur = h, pre = nullptr;
	while (cur) {
		if (cur->left == nullptr) {
			cout << cur->val << ' ';
			cur = cur->right;
			continue;
		}
		pre = cur->left;
		while (pre->right != nullptr && pre->right != cur) {
			pre = pre->right;
		}
		if (pre->right == nullptr) {
			pre->right = cur;
			cur = cur->left;
		}
		else {
			pre->right = nullptr;
			cout << cur->val << ' ';
			cur = cur->right;
		}
	}
}

参考文章

链接：https://leetcode-cn.com/problems/find-mode-in-binary-search-tree/solution/er-cha-sou-suo-shu-zhong-de-zhong-shu-by-leetcode-/
来源：力扣（LeetCode）