码迷,mamicode.com
首页 > 编程语言 > 详细

二叉树——遍历篇(c++)

时间:2017-12-31 12:51:18      阅读:177      评论:0      收藏:0      [点我收藏+]

标签:span   遍历二叉树   顺序   方便   基本   广度   逻辑   优先   设置   

二叉树——遍历篇

二叉树很多算法题都与其遍历相关,笔者经过大量学习并进行了思考和总结,写下这篇二叉树的遍历篇。

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);
    }
  }

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

?

二叉树——遍历篇(c++)

标签:span   遍历二叉树   顺序   方便   基本   广度   逻辑   优先   设置   

原文地址:https://www.cnblogs.com/pz-Feng/p/8119681.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!