二叉树-DFS非递归算法（前/中/后序）「数据结构算法精讲」

最新推荐文章于 2024-03-01 15:18:32 发布
最新推荐文章于 2024-03-01 15:18:32 发布
阅读量1.5k 收藏 15
点赞数 5
分类专栏： 数据结构 文章标签： 算法 二叉树 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bbbling/article/details/117337983
版权

前言：在递归遍历的代码中，我们只需要不断调用函数自身，就可以实现遍历。要写出二叉树的非递归算法，主要任务就是用自己定义的栈来代替系统栈的功能。

完整代码见文章末尾

DFS-先序-非递归算法（一）

第一种先序算法理解起来比较简单，
以下图这个比较简单的二叉树为例：
在这里插入图片描述

此算法的循环跳出条件是：栈不为空（括号中为栈的当前状态）。

  1. （栈顶｜空｜栈底）首先需要根节点（1）入栈，开始循环；

  2. （栈顶｜1｜栈底）出栈，访问出栈元素（1），将（1）的右孩子（4）入栈，将（1）的左孩子（2）入栈；

    PS：右孩子先入栈，左孩子后入栈，是由于栈后进先出的特殊结构，后入栈的左孩子会被优先访问，正好符合先序遍历“先左后右”的特点。

  3. （栈顶｜2 4｜栈底）出栈，访问出栈元素（2），将（2）的右孩子（5）入栈，将（2）的左孩子（3）入栈；

  4. （栈顶｜3 5 4｜栈底）出栈，访问出栈元素（3），（3）无右孩子，不做操作，（3）无左孩子，不做操作；

  5. （栈顶｜5 4｜栈底）出栈，访问出栈元素（5），（5）无右孩子，不做操作，（5）无左孩子，不做操作；

  6. （栈顶｜4｜栈底）出栈，访问出栈元素（4），（4）无右孩子，不做操作，（4）无左孩子，不做操作；

  7. 此时栈为空，算法结束。

最终访问元素的次序为：1、2、3、5、4。

代码如下：

void preorderNonrecursion1(BTNode *bt) // 深度优先非递归算法（一）
{
    if(bt != NULL) // 二叉树不为空时执行
    {
        BTNode *Stack[50]; // 定义一个栈
        int top = -1; // 初始化栈
        BTNode *p; // 临时节点p
        Stack[++top] = bt; // 根节点入栈
        while (top != -1)
        {
            p = Stack[top--]; // 栈顶元素出栈
            cout << p->data << ' '; // 访问栈顶节点
            if(p->rchild != NULL) // 若栈顶节点的存在右孩子
            {
                Stack[++top] = p->rchild; // 右孩子入栈
            }
            if(p->lchild != NULL) // 若栈顶节点的存在左孩子
            {
                Stack[++top] = p->lchild; // 左孩子入栈
            }
        }
        cout << endl;
    }
}

DFS-先序-非递归算法（二）

比上一种先序方法稍难，但其实原理也很容易理解。
在这里插入图片描述

此算法的循环跳出条件是：栈不为空且当前节点不为空（括号中为栈的当前状态）。

该算法在进栈、出栈的过程中可能会出现栈空的状态，但此时其实遍历还没有结束，所以需要添加一个 “p非空” 的条件来维持循环的进行。

  1. （栈顶｜空｜栈底）访问节点（1），节点（1）入栈，连续访问左子树开始，准备访问当前节点（1）的左孩子（2）；

  2. （栈顶｜1｜栈底）访问节点（2），节点（2）入栈，准备访问当前节点（2）的左孩子（3）；

  3. （栈顶｜2 1｜栈底）访问节点（3），节点（3）入栈，准备访问当前节点（3）的左孩子（^）；

  4. （栈顶｜3 2 1｜栈底）节点（3）的左孩子为空， 连续访问左子树结束，栈顶出栈（3），准备访问当前节点（3）的右孩子（^）；

  5. （栈顶｜2 1｜栈底）节点（3）的右孩子为空，栈顶出栈（2），准备访问当前节点（2）的右孩子（5）；

  6. （栈顶｜1｜栈底）访问节点（5），节点（5）入栈，连续访问左子树开始，准备访问当前节点（5）的左孩子（^）；

  7. （栈顶｜5 1｜栈底）节点（5）的左孩子为空，连续访问左子树结束，栈顶出栈（5），准备访问当前节点（5）的右孩子（^）；

  8. （栈顶｜1｜栈底）节点（5）的右孩子为空，栈顶出栈（1），准备访问当前节点（1）的右孩子（4）；

    此时栈已经出现了空的状态，但其实遍历还没有结束也不能结束，所以整个算法循环还需要添加一个 “p非空” 的条件来维持循环的进行。

  9. （栈顶｜空｜栈底）访问节点（4），节点（4）入栈，连续访问左子树开始，准备访问当前节点（4）的左孩子（^）；

  10. （栈顶｜空｜栈底）节点（4）的左孩子为空，连续访问左子树结束，准备访问当前节点（4）的右孩子（^）；

  11. （栈顶｜空｜栈底）当访问到节点（4）的右孩子时，该节点为空，此时栈也为空，算法结束。

最终访问元素的次序为：1、2、3、5、4。

非递归先序代码如下：

void preorderNonrecursion2(BTNode *bt) // 深度优先前序非递归算法（二）
{
    if(bt != NULL) // 二叉树不为空时执行
    {
        BTNode *Stack[50]; // 定义一个栈
        int top = -1; // 初始化栈
        BTNode *p = bt; // 临时节点p
        while (top != -1 || p != NULL)
        {
            while (p != NULL)
            {
                cout << p->data << ' '; // 访问栈顶节点
                Stack[++top] = p; // 当前节点入栈
                p = p->lchild;
            }
            // 当前节点没有左孩子时
            if(top != -1) // 在栈不为空的情况下
            {
                p = Stack[top--]; // 栈顶元素出栈
                p = p->rchild;
            }
        }
        cout << endl;
    }
}

DFS-中序-非递归算法

如果你还没有搞先序算法的话，建议多读几遍上面的例子再接着看。
如果你已经完全明白了上面的算法（二），那么中序非递归对你来说会非常简单，只不过是访问元素的位置换了一个地方。

对比一下「中序」和「先序」的代码，一目了然：
在这里插入图片描述

非递归中序代码如下：

void inorderNonrecursion(BTNode *bt) // 深度优先中序非递归遍历算法
{
    if(bt != NULL) // 二叉树不为空时执行
    {
        BTNode *Stack[50]; // 定义一个栈
        int top = -1; // 初始化栈
        BTNode *p = bt; // 临时节点p
        // 中序遍历可能出现栈为空但二叉树还未遍历完成的情况
        // 所以需要两个判断条件结合
        while (top != -1 || p != NULL)
        {
            while(p != NULL) // 优先访问当前节点的左孩子（如果存在）
            {
                Stack[++top] = p;
                p = p->lchild;
            }
            if(top != -1) // 在栈不为空的情况下
            {
                p = Stack[top--]; // 栈顶元素出栈
                cout << p->data << ' '; // 访问栈顶节点
                p = p->rchild;
            }
        }
        cout << endl;
    }
}

DFS-后序-非递归算法

后续非递归的算法非常巧妙，我们先手工写一下遍历序列看看。
在这里插入图片描述

  1. 先序非递归遍历：1、2、3、5、4

  2. 将先序非递归中对左右子树的遍历交换顺序：1、4、2、5、3（逆后序遍历）

    逆后序遍历指的是：将先序遍历的左、右子树遍历顺序交换的遍历方式。

  3. 将(2)的结果逆序：3、5、2、4、1

  4. 后序非递归遍历：3、5、2、4、1

似乎发现了他们之间的一些联系：我们先把先序遍历中左右子树的遍历顺序交换得到逆后序遍历，再将逆后序遍历的结果逆序，就得到了后序遍历的结果。

因此我们需要两个栈，一个栈stack1用来辅助做逆后序遍历，并将结果序列压入另一个栈stack2，然后将stack2中的元素全部出栈（逆序），所得到的序列即为后序遍历序列。

由于先序遍历的过程我们已经梳理过，这里直接上代码：
代码和先序遍历只有一点不同，可以对比着看。

void postorderNonrecursion(BTNode *bt) // 深度优先后序非递归算法
{
    if(bt != NULL) // 二叉树不为空时执行
    {
        // 定义两个栈
        BTNode *Stack1[50]; // 辅助做逆后序遍历
        int top1 = -1;
        BTNode *Stack2[50]; // 存储最终结果
        int top2 = -1;
        BTNode *p; // 临时节点p
        Stack1[++top1] = bt; // 根节点入栈
        while (top1 != -1)
        {
            p = Stack1[top1--]; // 栈顶元素出栈
            Stack2[++top2] = p; // 访问栈顶节点 存储到结果栈2
            if(p->lchild != NULL) // 若栈顶节点的存在右孩子
            {
                Stack1[++top1] = p->lchild; // 右孩子入栈
            }
            if(p->rchild != NULL) // 若栈顶节点的存在左孩子
            {
                Stack1[++top1] = p->rchild; // 左孩子入栈
            }
        }
        while(top2 != -1)  // 输出结果
        {
            p = Stack2[top2--]; // 出栈序列即为后序遍历序列
            cout << p->data << ' ';
        }
        cout << endl;
    }
}

完整代码运行结果：
在这里插入图片描述

完整可运行代码：

#include <stdio.h>
#include <iostream>
using namespace std;

typedef struct BTNode // 定义二叉树的节点
{
    char data; // 节点数据类型
    struct BTNode *lchild; // 左孩子
    struct BTNode *rchild; // 右孩子
}BTNode;

BTNode *createBinaryTree() // 前序递归创建二叉树
{
    BTNode *p;
    char ch;
    cin >> ch;
    if(ch == '#')
    {
        p = NULL;
    }
    else
    {
        p = (BTNode*)malloc(sizeof(BTNode));
        p->data = ch;
        p->lchild = createBinaryTree();
        p->rchild = createBinaryTree();
    }
    return  p;
}

void preorderNonrecursion1(BTNode *bt) // 深度优先前序非递归算法（一）
{
    if(bt != NULL) // 二叉树不为空时执行
    {
        BTNode *Stack[50]; // 定义一个栈
        int top = -1; // 初始化栈
        BTNode *p; // 临时节点p
        Stack[++top] = bt; // 根节点入栈
        while (top != -1)
        {
            p = Stack[top--]; // 栈顶元素出栈
            cout << p->data << ' '; // 访问栈顶节点
            if(p->rchild != NULL) // 若栈顶节点的存在右孩子
            {
                Stack[++top] = p->rchild; // 右孩子入栈
            }
            if(p->lchild != NULL) // 若栈顶节点的存在左孩子
            {
                Stack[++top] = p->lchild; // 左孩子入栈
            }
        }
        cout << endl;
    }
}

void preorderNonrecursion2(BTNode *bt) // 深度优先前序非递归算法（二）
{
    if(bt != NULL) // 二叉树不为空时执行
    {
        BTNode *Stack[50]; // 定义一个栈
        int top = -1; // 初始化栈
        BTNode *p = bt; // 临时节点p
        while (top != -1 || p != NULL)
        {
            while (p != NULL)
            {
                cout << p->data << ' '; // 访问栈顶节点
                Stack[++top] = p; // 当前节点入栈
                p = p->lchild;
            }
            // 当前节点没有左孩子时
            if(top != -1) // 在栈不为空的情况下
            {
                p = Stack[top--]; // 栈顶元素出栈
                p = p->rchild;
            }

        }
        cout << endl;
    }
}

void inorderNonrecursion(BTNode *bt) // 深度优先中序非递归遍历算法
{
    if(bt != NULL) // 二叉树不为空时执行
    {
        BTNode *Stack[50]; // 定义一个栈
        int top = -1; // 初始化栈
        BTNode *p = bt; // 临时节点p
        // 中序遍历可能出现栈为空但二叉树还未遍历完成的情况
        // 所以需要两个判断条件结合
        while (top != -1 || p != NULL)
        {
            while(p != NULL) // 优先访问当前节点的左孩子（如果存在）
            {
                Stack[++top] = p; // 入栈
                p = p->lchild;
            }
            if(top != -1) // 在栈不为空的情况下
            {
                p = Stack[top--]; // 栈顶元素出栈
                cout << p->data << ' '; // 访问栈顶节点
                p = p->rchild;
            }
        }
        cout << endl;
    }
}

void postorderNonrecursion(BTNode *bt) // 深度优先后序非递归算法
{
    if(bt != NULL) // 二叉树不为空时执行
    {
        // 定义两个栈
        BTNode *Stack1[50]; // 辅助做逆后序遍历
        int top1 = -1;
        BTNode *Stack2[50]; // 存储最终结果
        int top2 = -1;
        BTNode *p; // 临时节点p
        Stack1[++top1] = bt; // 根节点入栈
        while (top1 != -1)
        {
            p = Stack1[top1--]; // 栈顶元素出栈
            Stack2[++top2] = p; // 访问栈顶节点 存储到结果栈2
            if(p->lchild != NULL) // 若栈顶节点的存在右孩子
            {
                Stack1[++top1] = p->lchild; // 右孩子入栈
            }
            if(p->rchild != NULL) // 若栈顶节点的存在左孩子
            {
                Stack1[++top1] = p->rchild; // 左孩子入栈
            }
        }
        while(top2 != -1)  // 输出结果
        {
            p = Stack2[top2--]; // 出栈序列即为后序遍历序列
            cout << p->data << ' ';
        }
        cout << endl;
    }
}

int main()
{
    cout << "开始创建二叉树（输入用例：123##5##4##）" << endl;
    BTNode *root = NULL;
    root = createBinaryTree();
    cout << "二叉树建立成功！" << endl;
    cout << "深度优先先序非递归遍历二叉树(1)：" << endl;
    preorderNonrecursion1(root);
    cout << "深度优先先序非递归遍历二叉树(2)：" << endl;
    preorderNonrecursion2(root);
    cout << "深度优先中序非递归遍历二叉树：" << endl;
    inorderNonrecursion(root);
    cout << "深度优先后序非递归遍历二叉树：" << endl;
    postorderNonrecursion(root);
    return 0;
}
_Pooooooocky
关注
  • 5
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的非递归后序遍历算法实例详解
01-19
前序、中序、后序的非递归遍历中，要数后序最为麻烦，如果只在栈中保留指向结点的指针，那是不够的，必须有一些额外的信息存放在栈中。方法有很多，这里只举一种，先定义栈结点的数据结构 代码如下:typedef struct{Node * p; int rvisited;}SNode //Node 是二叉树的结点结构，rvisited==1代表p所指向的结点的右结点已被访问过。 lastOrderTraverse(BiTree bt){　　//首先，从根节点开始，往左下方走，一直走到头，将路径上的每一个结点入栈。　　p = bt;　　while(bt){　　　　push(bt, 0); //push到
深度优先搜索(DFS) ----- 递归与非递归写法及DFS拓展
qq_44872260的博客
08-18 2026
一.DFS概述 1.Depth First Search 是遍历图的常用方法之一，它类似于与数的先根遍历，是数的先根遍历的推广。 DFS的基本实现思想是从图中的某个顶点v出发，访问此顶点，然后依次从v的未被访问的邻接点出发深度优先遍历图，直至图中所有和v路径相通的顶点都被访问到。若此时图中尚有顶点未被访问(说明该图不是连通图)，则另选图中一个未曾被访问的顶点作为起始点，重复上诉过程，直至图中所有的顶点都被访问到为止。 eg：如下图DFS的遍历的详细过程，选择起始点为v12.实现DFS的关键要点 （1）结合上
数据结构：二叉搜索树（非递归实现）
最新发布
decade777555的博客
03-01 998
二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树，其中每个节点的值大于其左子树中所有节点的值，小于其右子树中所有节点的值。如果不为根节点，那么需要判断该节点是prev(该节点的父节点）的左孩子还是右孩子，让对应的指针指向该节点的左孩子即可。不为根节点，判断该节点是prev(该节点的父节点）的左孩子还是右孩子，让对应的指针指向该节点的右孩子即可。如果为根节点，那么直接让该节点的左孩子变为根节点即可。如果为根节点，同上操作，只是变为对该节点右孩子的操作。
数据结构-二叉树递归-非递归实现
04-26
数据结构实验二叉树用递归实现先序遍历、中序遍历和后序遍历，用几种不同非递归方法实现了中序遍历，代码附有详细注释
C语言数据结构之二叉树的非递归后序遍历算法
08-29
主要介绍了C语言数据结构之二叉树的非递归后序遍历算法的相关资料,希望通过本文能帮助到大家，让大家实现这样的功能，需要的朋友可以参考下
PHP基于非递归算法实现先序、中序及后序遍历二叉树操作示例
10-18
主要介绍了PHP基于非递归算法实现先序、中序及后序遍历二叉树操作,结合实例形式分析了php采用非递归算法对二叉树进行先序、中序及后序遍历操作的原理与具体实现技巧,需要的朋友可以参考下
DFS（深度优先搜索）的递归与非递归
学习永无止境
04-11 1万+
DFS，depth-first search，深度优先搜索。顾名思义，从一个节点出发，尽可能往下遍历，即尽可能离“家”远一点，这个思想其实就是树结构遍历中的先序遍历。 那么从上述话语中，我们可以很容易地判断出需要用到递归，其实DFS的常规构造方法也就是用到递归的，但是我们还要考虑到一个问题，那么就是如果一个图足够大，比如有上万个节点，上万条边，那么估计用递归运行DFS我们的电脑会瞬间卡死。。。因为递归的代价实在是太大了，图如果小一点还好，不是特别明显，一旦图过大，递归的劣势会被无限放大，因此这里除了用递归来
DFS非递归算法
Read by heart
06-02 2084
【原理】 【数据源】 T188 【核心代码】 //非递归DFS遍历算法 void NonRecurDFS(AGraph* g, int v0) { int stack[maxSize], top = -1; ArcNode* p = NULL; int j; Initialize(g->n);//初始化访问数组 //将起始点入栈并访问 stack[++top] = ...
算法——DFS的非递归实现
weixin_45927758的博客
06-06 745
思路： #include<iostream> #include<stack> #include<vector> using namespace std; //边表节点 typedef struct ADTnode { int node; ADTnode*next; ADTnode(int x,ADTnode*p):node(x),next(p) {} } ADTnode; //顶点表节点 typedef struct upnode { .
深度优先搜索DFS的非递归实现
海马有力量的博客
11-11 884
DFS的非递归实现借助栈，除第一个节点外其余节点逆序。 输入： 5 6 1 2 2 3 3 5 1 4 4 2 4 5 输出： 1 4 5 3 2 #include<stdio.h> #include<stdlib.h> #define N 100 typedef int ElemType; struct stack{ ElemType data[N]; int top; }; int n; int a[N][N],vis[N]; void DFS(int pos){ /
使用栈实现DFS(非递归DFS)
ZD的博客
04-07 2万+
图片摘自：点击打开链接 #include #include #define N 4 //定义图中点个数 int a[N][N] = {{-1,1,1,-1},{1,-1,-1,1},{1,-1,-1,1},{-1,1,1,-1}}; //邻接矩阵，-1无边 int label[N] = {0}; //标记数组，0未标记 //定义栈及其方法 struct Stack {
习题2-5 最短路径和简单路径
m0_65185254的博客
12-08 866
数据结构
深度优先搜索（DFS）递归与非递归实现逻辑详解
热门推荐
年少很低调
01-07 3万+
递归与非递归： 数据结构对于学习编程的人来说是非常重要的，我们在现实生活碰到的各种烦难问题可以用递归来实现，一个递归思想就把问题给简单化了，但是我们都知道递归是非常耗时的，一旦数据量庞大起来，递归次数多了，这个时间是非常恐怖的。所以一般我们都会把一些递归问题给非递归化，来达到某一定的效率。通常递归转化为非递归用到了栈和队列，今天就详解用栈来实现转化的逻辑处理，并且以（01背包为主讲
非递归的方式实现排列和组合类DFS
INGNIGHT的专栏
04-17 615
而第 i 个元素，比原数组小的情况有多少种，其实就是 A[i] 右侧有多少元素比 A[i] 小，乘上 A[i] 右侧元素全排列数，即 A[i] 右侧元素数量的阶乘。也即 [3,7,4,1,X] ， [3,7,1,X,X] ， [3,1或4,X,X,X] ， [1,X,X,X,X]。因为这会影响 A[i] 右侧元素的排列数，此时的排列数计算方法为总元素数的阶乘，除以各元素值个数的阶乘，例如 [1, 1, 1, 2, 2, 3] ，排列数为。例如排列 [1, 2, 4] 是第 1 个排列。
全排列问题的细节讲解（递归：DFS、非递归实现）
一只攻城狮的博客
12-24 943
全排列问题的细节讲解（递归：DFS、非递归实现） 在这里插入代码片 package Permutation; /** * @Description Full Permutation Algorithm * @author zhuwei * @Email [email protected] * @version v1.0 */ public class FullPermutaion { public static void main(String[] args) { int[] n
【算法】十大经典排序算法（动图演示）
AlvinHuntley的博客
10-28 301
0、算法概述 0.1 算法分类 十种常见排序算法可以分为两大类： 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。 0.2 算法复杂度 0.3 相关概念 稳定：如果a原本在b前面，而a=...
(迷宫问题)DFS(递归+非递归)
m0_74206992的博客
10-10 240
例子:迷宫
DFS非递归
u014204761的博客
10-02 1020
def DFS(root): # 非递归DFS ''' 利用栈完成非递归 1 初始化根节点，标记为访问过，入栈 2 取栈顶元素不出栈： 如果该元素有未访问的邻接点，访问该邻接点，入栈， 如果该元素所有邻接点都被访问或没有邻接点，出栈 ''' ...
// 后序遍历二叉树的非递归算法
04-30
可以使用栈来实现二叉树的后序遍历。具体步骤如下： 1. 定义一个栈，将根节点压入栈中。 2. 定义一个变量 lastVisit 来记录上一次访问的节点。 3. 循环执行以下操作，直到栈为空： - 将栈顶节点出栈，如果该节点的右子树为空或者已经访问过，则访问该节点，并将 lastVisit 设置为该节点。 - 否则，将该节点再次压入栈中，并将其右子树入栈。 - 如果该节点的左子树不为空且上一次访问的节点不是该节点的左子节点和右子节点，则将其左子树入栈。 下面是 C++ 实现代码： ```cpp void postOrderTraversal(TreeNode* root) { if (root == nullptr) return; stack<TreeNode*> s; s.push(root); TreeNode* lastVisit = nullptr; while (!s.empty()) { TreeNode* node = s.top(); if ((node->right == nullptr && node->left == nullptr) || (lastVisit != nullptr && (lastVisit == node->left || lastVisit == node->right))) { cout << node->val << " "; s.pop(); lastVisit = node; } else { if (node->right) s.push(node->right); if (node->left) s.push(node->left); } } } ``` 该算法的时间复杂度为 O(n)，空间复杂度为 O(h)，其中 h 为树的高度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值