二叉树——遍历篇
二叉树很多算法题都与其遍历相关，笔者经过大量学习并进行了思考和总结，写下这篇二叉树的遍历篇。
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);
}
}原创所有，转载务必注明出处。
?
