二叉树——遍历篇

二叉树很多算法题都与其遍历相关，笔者经过大量学习、思考，整理总结写下二叉树的遍历篇,涵盖递归和非递归实现。

1、二叉树数据结构及访问函数

#include <stdio.h>

#include <iostream>

#include <stack>

using namespace std;

struct BTNode

{

	int value;

	struct BTNode *left, *right;

	BTNode(int value_) :value(value_),left(NULL),right(NULL){};

};

//访问函数：可根据实际进行修改

void visit(BTNode* node)

{

	cout << node->value << " ";

}

2、二叉树的遍历——深度优先遍历（DFS）（先序、中序、后序）

2.1、具体遍历顺序

• 先序遍历：访问根节点、先序遍历左孩子、先序遍历右孩子 （根、左、右）

• 中序遍历：中序遍历左孩子、访问根节点、中序遍历右孩子 （左、根、右）

• 后序遍历：后序遍历左孩子、后序遍历右孩子、访问根节点 （左、右、根）

2.2、递归遍历

/**

* 先序遍历二叉树

*/

void PreOrder(BTNode* root)

{

	if (root)

	{

		visit(root);

		PreOrder(root->left);

		PreOrder(root->right);

	}

}

/**

* 中序遍历二叉树

*/

void InOrder(BTNode* root)

{

	if (root)

	{

		InOrder(root->left);

		visit(root);

		InOrder(root->right);

	}

}

/**

* 后序遍历二叉树

*/

void PostOrder(BTNode* root)

{

	if (root)

	{

		PostOrder(root->left);

		PostOrder(root->right);

		visit(root);

	}

}

2.3、非递归遍历——借助栈

• 借助栈，可以实现非递归遍历。
• 在这里三种非递归遍历都总结和介绍一种算法思路，其栈中保存的节点可以用于路径搜索类的题目，即保存着从根节点到当前访问节点最短路径的所有节点信息，以*标记。
• 介绍仅用于遍历访问的简单思路，栈中信息难以应用于搜索路径类的题目。

2.31 先序非递归遍历

* PreOrder_1a

算法过程：

由先序遍历过程可知，先序遍历的开始节点是根节点，然后用指针p 指向当前要处理的节点，沿着二叉树的左下方逐一访问，并将它们一一进栈，直至栈顶节点为最左下节点，指针p为空。此时面临两种情况。（1）对栈顶节点的右子树访问（如果有的话，且未被访问），对右子树进行同样的处理；（2）若无右子树，则用指针last记录最后一个访问的节点，指向栈顶节点，弹栈。如此重复操作，直至栈空为止。

void PreOrder_1a(BTNode *root)

{

	if (NULL == root) return;

	stack<BTNode*> stack;

	BTNode *p = root;

	BTNode *last = NULL;

	do {

		while (p)

		{

			visit(p);

			stack.push(p);

			p = p->left;

		}

		//此时p = NULL，栈顶节点为左子树最左节点

		if (!stack.empty())

		{

			BTNode *t = stack.top();

			if (t->right != NULL && t->right != last)

			{

				p = t->right;

			}

			else

			{//若无右子树，则指针P仍为空，则不断弹栈（沿着双亲方向）寻找有未被访问的右子树的节点

				last = t;

				stack.pop();

			}

		}

	} while (!stack.empty());

}

* PreOrder_1b

算法过程：此算法与PreOrder_1a有异曲同工之处，巧妙之处在于对上述两种情况的处理。指针p记录当前栈顶结点的前一个已访问的结点。若无右子树、或者右子树已被访问，则用指针p记录当前栈顶节点，弹栈，不断沿着双亲方向寻找有未访问右子树的节点，找到即退出循环，否则直至栈空。当栈顶节点的右孩子是p时，则将cur指向右孩子，设置flag =0 ,退出当前搜索循环（不断弹栈，搜索有右节点且未被访问的祖先节点），然后对右子树进行同样的处理。如此反复操作，直至栈空为止。

void PreOrder_1b(BTNode *root)

{

	if (NULL == root) return;

	stack<BTNode*>stack;

	int flag;

	BTNode *cur = root,*p;

	do{

		while (cur)

		{

			visit(cur);

			stack.push(cur);

			cur = cur->left;

		}

     //执行到此处时，栈顶元素没有左孩子或左子树均已访问过

		p = NULL;      //p指向栈顶结点的前一个已访问的结点

		flag = 1;	   //表示*cur的左孩子已访问或者为空

		while (!stack.empty() && flag == 1)

		{

			cur = stack.top();

			if (cur->right == p)  //表示右孩子结点为空或者已经访问完右孩子结点

			{

				stack.pop();

				p = cur;	//p指向刚访问过的结点

			}

			else

			{

				cur = cur->right; //cur指向右孩子结点

				flag = 0;		//设置未被访问的标记

			}

		}

	} while (!stack.empty());

}

PreOrder_2a && PreOrder_2b

PreOrder_2a 和 PreOrder_2b 算法思路大体相同，PreOrder_2a 实现比较简洁

算法过程：

用指针p指向当前要处理的节点，沿着左下方向逐一访问并压栈，直至指针P为空，栈顶节点为最左下节点。然后p指向栈顶节点的右节点（不管是否空）；若右节点为空，则继续弹栈。若右节点非空，则按上述同样处理右节点。如此重复操作直至栈空为止。

缺陷：PreOrder_2 当访问栈顶节点的右节点时，会丢失当前栈顶节点信息，导致从根节点到当前栈顶节点的右节点路径不完整。

优点：算法思路清晰易懂，逻辑简单。

void PreOrder_2a(BTNode *root)

{

	if (NULL == root) return;

	BTNode *p = root;

	stack<BTNode*> stack;

	while (p || !stack.empty())

	{

		if (p)

		{

			visit(p);

			stack.push(p);

			p = p->left;

		}

		else

		{

			BTNode *top = stack.top();

			p = top->right;

			stack.pop();

		}

	}

}

void PreOrder_2b(BTNode *root)

{

	if (NULL == root) return;

	BTNode *p = root;

	stack<BTNode*> stack;

	while (!stack.empty() ||p)

	{

		while (p)

		{

			visit(p);

			stack.push(p);

			p = p->left;

		}

		if (!stack.empty())

		{

			BTNode *top = stack.top();

			p = top->right;

			stack.pop();

		}

	}

}

PreOrder_3

算法过程：

用指针p指向当前要处理的节点。先把根节点压栈，栈非空时进入循环，出栈栈顶节点并访问，然后按照先序遍历先左后右的逆过程把当前节点的右节点压栈（如果有的话），再把左节点压栈（如果有的话）。如此重复操作，直至栈空为止。

特点：栈顶节点保存的是先序遍历下一个要访问的节点，栈保存的所有节点不是根到要访问节点的路径。

void PreOrder_3(BTNode *root)

{

	if (NULL == root) return;

	BTNode *p = root;

	stack<BTNode *> stack;

	stack.push(p);

	while (!stack.empty())

	{

		p = stack.top();

		stack.pop();

		visit(p);

		if (p->right)

			stack.push(p->right);

		if (p->left)

			stack.push(p->left);

	}

}

2.32 中序非递归遍历

中序遍历非递归算法要把握访问栈顶节点的时机。

* InOrder_1

算法过程：

用指针cur指向当前要处理的节点。先扫描（并非访问）根节点的所有左节点并将它们一一进栈，直至栈顶节点为最左下节点，指针cur为空。

此时主要分两种情况。（1）栈顶节点的左节点为空或者左节点已访问，访问栈顶节点（访问位置很重要！），若有右节点则将cur指向右节点，退出当前while循环，对右节点进行上述同样的操作，若无右节点则用指针p记录站顶节点并弹栈；（2）站顶节点的右节点为空或已访问，用指针p记录站顶节点并弹栈。

内部第二个while循环可称为访问搜索循环，在栈顶节点的左节点为空或者左节点已访问的情况下，访问栈顶节点，若有右节点，则退出循环，否则不断弹栈。

如此重复操作，直至栈空为止。

void InOrder_1(BTNode *root)

{

	if (NULL == root) return;

	stack<BTNode *>stack;

	BTNode *cur = root,*p = NULL;

	int flag = 1;

	do{

		while (cur){

			stack.push(cur);

			cur = cur->left;

		}

     //执行到此处时，栈顶元素没有左孩子或左子树均已访问过

		p = NULL;      //p指向栈顶结点的前一个已访问的结点

		flag = 1;	   //表示*cur的左孩子已访问或者为空

		while (!stack.empty() && flag)

		{

			cur = stack.top();

			if (cur->left == p) //左节点为空 或者左节点已访问

			{

				visit(cur);     //访问当前栈顶节点

				if (cur->right) //若有右节点  当前节点指向右节点，并退出当前循环，进入上面的压栈循环

				{

					cur = cur->right;

					flag = 0;   //flag = 0 标记右节点的左子树未访问

				}

				else           //当前节点没有右节点，P记录访问完的当前节点，弹栈

				{

					p = cur;

					stack.pop();

				}

			}

			else      // 此时 cur->right == P 即访问完右子树 ,P记录访问完的当前节点,弹栈

			{

				p = cur;

				stack.pop();

			}

		}

	} while (!stack.empty());

}

InOrder_2a && InOrder_2b

算法过程：

用指针p指向当前要处理的节点。先扫描（并非访问）根节点的所有左节点并将它们一一进栈，当无左节点时表示栈顶节点无左子树，然后出栈这个节点，并访问它，将p指向刚出栈节点的右孩子，对右孩子进行同样的处理。如此重复操作，直至栈空为止。

需要注意的是：当节点*p的所有左下节点入栈后，这时的栈顶节点要么没有左子树，要么其左子树已访问，就可以访问栈顶节点了！

InOrder_2a 、 InOrder_2b 与 PreOrder_1a 、PreOrder_1b 代码基本相同，唯一不同的是访问节点的时机，把握好可方便理解和记忆。

void InOrder_2a(BTNode *root)

{

	if (NULL == root) return;

	BTNode *p = root;

	stack<BTNode *>stack;

	while (p || !stack.empty())

	{

		while (p)

		{

			stack.push(p);

			p = p->left;

		}

		if (!stack.empty())

		{

			p = stack.top();

			visit(p);

			stack.pop();

		}

	}

}

void InOrder_2b(BTNode *root)

{

	if (NULL == root) return;

	stack<BTNode *>stack;

	BTNode *p = root;

	while (p || !stack.empty())

	{

		while (p)

		{

			stack.push(p);

			p = p->left;

		}

		if (!stack.empty())

		{

			p = stack.top();

			visit(p);

			p = p->right;

			stack.pop();

		}

	}

}

2.33 后序非递归遍历

*PostOrder_1

算法过程：

用指针cur指向当前要处理的节点。先扫描（并非访问）根节点的所有左节点并将它们一一进栈，直至栈顶节点为最左下节点，指针cur为空。此时有两种情况。（1）栈顶节点的右节点为空或已访问，访问当前栈顶节点（访问时机很重要！），用指针p保存刚刚访问过的节点（初值为NULL），弹栈；（2）栈顶节点有未被访问的右节点，设置flag，退出当前访问搜索循环。如此重复处理，直至栈空为止。

void PostOrder_1(BTNode *root)

{

	if (NULL == root) return;

	stack<BTNode*>stack;

	int flag;

	BTNode *cur = root, *p;

	do{

		while (cur)

		{

			stack.push(cur);

			cur = cur->left;

		}

      //执行到此处时，栈顶元素没有左孩子或左子树均已访问过

		p = NULL;      //p指向栈顶结点的前一个已访问的结点

		flag = 1;	   //表示*cur的左孩子已访问或者为空

		while (!stack.empty() && flag == 1)

		{

			cur = stack.top();

			if (cur->right == p)

			{//表示右孩子结点为空，或者已经访问cur的右子树（p必定是后序遍历cur的右子树最后一个访问节点）

				visit(cur);

              	p = cur;	//p指向刚访问过的结点

              	stack.pop();

			}

			else

			{

				cur = cur->right; //cur指向右孩子结点

				flag = 0;		 //表示*cur的左孩子尚未访问过

			}

		}

	} while (!stack.empty());

}

PostOrder_2

算法过程：

先把根节点压栈，用指针p记录上一个被访问的节点。在栈为空时进入循环，取出栈顶节点。

此时有两种情况：

（1）访问当前节点，注意把握访问的时机，如果当前节点是叶子节点，访问当前节点；如果上一个访问的节点是当前节点的左节点（说明无右节点），访问当前节点；如果上一个访问的节点是当前节点的右节点（说明左右节点都有），访问当前节点；指针p记录当前访问的节点，弹栈。 所以，只有当前节点是叶子节点，或者上一个访问的节点是当前节点的左节点（无右） 或右节点（左右都有） ，才可以访问当前节点。

（2）压栈。 后序遍历顺序为 左、右、根，按照逆序，先把右压栈，再把左压栈（如果有的话）。

如此重复操作，直至栈空为止。

void PostOrder_2(BTNode* root)

{

	if (NULL == root) return;

	BTNode *cur = root, *p=NULL;

	stack<BTNode*> stack;

	stack.push(root);

	while (!stack.empty())

	{

		cur = stack.top();

		if (cur->left == NULL && cur->right == NULL || (p!= NULL && (cur->left==p || cur->right == p)))

		{

			visit(cur);

			stack.pop();

			p = cur;

		}

		else

		{

			if (cur->right)

				stack.push(cur->right);

			if (cur->left)

				stack.push(cur->left);

		}

	}

}

3、二叉树的遍历——广度优先遍历（BFS）

• 二叉树的广度优先遍历，就是层次遍历，借助队列实现

  在进行层次遍历时，对某一层的节点访问完后，再按照对它们的访问次序对各个节点的左、右孩子顺序访问。这样一层一层进行，先访问的节点其左、右孩子也要先访问，与队列的操作原则比较吻合，且符合广度优先搜索的特点。

  算法过程：先将根节点进队，在队不空时循环；从队列中出列一个节点，访问它；若它有左孩子节点，将左孩子节点进队；若它有右孩子节点，将右孩子节点进队。如此重复操作直至队空为止。

  void LevelOrder(BTNode *root)

  {

  	if (NULL == root) return;

  	queue<BTNode*> queue;

  	queue.push(root);

  	BTNode* p;

  	while (!queue.empty())

  	{

  		p = queue.front();

  		queue.pop();

  		visit(p);

  		if (p->left)

  			queue.push(p->left);

  		if (p->right)

  			queue.push(p->right);

  	}

  }

原创所有，转载务必注明出处。

​