二叉树各种遍历算法

二叉树是许多算法题的常用结构，其遍历算法的各种变种就是各种题目。具体的顺序如下：

• 先序遍历：先根、后左、再右
• 中序遍历：先左、后根、再右
• 后序遍历：先左、后右、再根

递归版先序、中序、后序遍历

最简单、最直接的版本

#include <iostream>
using namespace std;

// 二叉树节点
struct Node
{
	int value;
	struct Node* left;
	struct Node* right;
	Node(int data) : value(data), left(nullptr), right(nullptr) {};
};

// 先序遍历
void PreOrder(Node* head)
{
	if (head == nullptr)
		return;
	cout << head->value << " ";
	PreOrder(head->left);
	PreOrder(head->right);
}

// 中序遍历
void InOrder(Node* head)
{
	if (head == nullptr)
		return;
	InOrder(head->left);
	cout << head->value << " ";
	InOrder(head->right);
}

// 后序遍历
void PosOrder(Node* head)
{
	if (head == nullptr)
		return;
	PosOrder(head->left);
	PosOrder(head->right);
	cout << head->value << " ";
}

int main()
{
	Node* n1 = new Node(1);
	Node* n2 = new Node(2);
	Node* n3 = new Node(3);
	Node* n4 = new Node(4);
	Node* n5 = new Node(5);
	n1->left = n2;
	n1->right = n3;
	n2->left = n4;
	n2->right = n5;
	PreOrder(n1);
	cout << endl;
	InOrder(n1);
	cout << endl;
	PosOrder(n1);
	cout << endl;
	delete n1;
	delete n2;
	delete n3;
	delete n4;
	delete n5;
	system("pause");
    return 0;
}

非递归版本

用递归方法解决的问题都能用非递归的方法来做，因为递归无非是使用了系统的函数栈来保存信息。我们自己申请一个栈来代替函数栈即可实现非递归方法。

先序遍历

先序遍历比较容易理解，首先将根节点入栈。从栈中取出栈顶节点，打印该点，接着先将右孩子入栈，再将左孩子入栈（因为栈的特点是先进后出，要先遍历左孩子就得后入栈）。不断重复该步骤直至栈为空。

void PreOrderUnRecur(Node* head)
{
	if (head)
	{
		stack<Node*> stack;
		stack.push(head);
		Node* cur;
		while (!stack.empty())
		{
			cur = stack.top();
			stack.pop();
			cout << cur->value << " ";
			// 右孩子先进栈，后出
			if (cur->right)
				stack.push(cur->right);
			if (cur->left)
				stack.push(cur->left);
		}
	}
}

中序遍历

令cur等于head
步骤1：先把cur入栈，然后不停让cur=cur->left，重复此步骤。即把cur下的所有左孩子节点入栈。直到cur为空。
步骤2：从栈中弹出栈顶给cur，打印该节点，然后令cur=cur->right，回到步骤2。
步骤3：当栈为空时且cur为空时，过程结束。
入栈的顺序可参考下图：

void InOrderUnRecur(Node* head)
{
	if (head)
	{
		stack<Node*> stack;
		Node* cur = head;
		while (!stack.empty() || cur != nullptr)
		{
			while (cur != nullptr)
			{
				stack.push(cur);
				cur = cur->left;
			}

			cur = stack.top();
			stack.pop();
			cout << cur->value << " ";
			cur = cur->right;
		}
	}
}

后序遍历

方法一：

申请两个栈s1、s2，先将头节点入栈s1。从s1中弹出栈顶节点记为cur，然后依次将cur的左孩子和右孩子压入s1。在这过程中每一个从s1中弹出的节点均压入s2。当s1为空后，从s2中依次弹出的节点便是后序遍历的次序。
主要就是利用两个栈来进行“倒腾“，压入s2的顺序为中、右、左，弹出的顺序就变成了左、右、中。

void PosOrderUnRecur(Node* head)
{
	if (head)
	{
		stack<Node*> s1, s2;
		s1.push(head);
		Node* cur;
		while (!s1.empty())
		{
			cur = s1.top();
			s1.pop();
			s2.push(cur);
			if (cur->left)
				s1.push(cur->left);
			if (cur->right)
				s1.push(cur->right);
		}
		while (!s2.empty())
		{
			cout << s2.top()->value << " ";
			s2.pop();
		}
	}
}

方法二：
申请一个栈，将头节点压入栈。
现在我们思考一下：当遍历到一个节点时，如何判断这次遍历是打印该点，还是先处理它的孩子呢？
有以下几种情况：

1. 该节点的左右孩子皆为空，即该节点为叶子节点，那么这次遍历就是打印该点。
2. 如果上一次打印的节点为该节点的右孩子，说明该节点的子树处理完毕，这次遍历就是打印该点。
3. 如果上一次打印的节点为该节点的左孩子，且该节点的右孩子为空，说明该节点的子树处理完毕，这次遍历就是打印该点。
4. 否则说明子树没有被访问过，按照右孩子、左孩子的顺序入栈。

void PosOrderUnRecur(Node* head)
{
	if (head)
	{
		stack<Node*> stack;
		stack.push(head);
		Node* last = nullptr;
		Node* top;
		while (!stack.empty())
		{
			top = stack.top();
			if ((top->left == nullptr && top->right == nullptr) || // 叶子节点
				(top->right == nullptr && last == top->left) || // 上个访问为左孩子，且右孩子为空
				last == top->right) // 上个访问为右孩子
			{
				cout << top->value << " ";
				last = top;
				stack.pop();
			}
			else
			{
				if (top->right)
					stack.push(top->right);
				if (top->left)
					stack.push(top->left);
			}
		}
	}
}

层次遍历

利用队列来做。

void LevelOrder(Node* head)
{
	if (head)
	{
		queue<Node*> queue;
		queue.push(head);
		Node* cur;
		while (!queue.empty())
		{
			cur = queue.front();
			queue.pop();
			cout << cur->value << " ";
			if (cur->left)
				queue.push(cur->left);
			if (cur->right)
				queue.push(cur->right);
		}
	}
}