非递归实现二叉树遍历（附c++完整代码）

最新推荐文章于 2023-03-15 15:45:48 发布
最新推荐文章于 2023-03-15 15:45:48 发布
阅读量354 收藏
点赞数
分类专栏： 数据结构
本文详细介绍了二叉树的前序、中序和后序遍历算法，包括递归和非递归实现方式，通过具体代码示例帮助读者深入理解二叉树遍历的原理与实践。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

原文：https://blog.youkuaiyun.com/happyjacob/article/details/83116702

先序、中序和后序遍历过程：遍历过程中经过结点的路线一样，只是访问各结点的时机不同。


从图中可以看到，前序遍历在第一次遇见元素时输出，中序遍历在第二次遇见元素时输出，后序遍历在第三次遇见元素时输出。

非递归算法实现的基本思路：使用堆栈

一、前序遍历
1、递归实现
遍历过程为：

访问根结点；
先序遍历其左子树；
先序遍历其右子树。
void ProOrderTraverse(BiTree tree)
{
    if (tree == NULL)
        return;
    cout << tree->data << " ";
    ProOrderTraverse(tree->lchild);
    ProOrderTraverse(tree->rchild);
}
1
2
3
4
5
6
7
8
2、非递归实现
void ProOrder(BiTree pRoot)
{
    if (pRoot == NULL)
        return;
    BiTree p = pRoot;
    stack<BiTree>s;

    while (p != NULL || !s.empty())
    {
        while (p != NULL)
        {
            s.push(p);
            cout << p->data << " ";
            p = p->lchild;
        }
        if (!s.empty())
        {
            p = s.top();
            s.pop();
            p = p->rchild;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
二、中序遍历
1、递归实现
遍历过程为：

中序遍历其左子树；
访问根结点；
中序遍历其右子树。
void midOrderTraverse(BiTree tree)
{
    if (tree == NULL)
        return;
    midOrderTraverse(tree->lchild);
    cout << tree->data << " ";
    midOrderTraverse(tree->rchild);
}
1
2
3
4
5
6
7
8
2、非递归实现
遇到一个结点，就把它压栈，并去遍历它的左子树；
当左子树遍历结束后，从栈顶弹出这个结点并访问它；
然后按其右指针再去中序遍历该结点的右子树。
void midOrder(BiTree pRoot)
{
    if (pRoot == NULL)
        return;
    BiTree p = pRoot;
    stack<BiTree>s;
    while (p != NULL || !s.empty())
    {
        while (p!=NULL)
        {
            s.push(p);
            p = p->lchild;
        }
        if (!s.empty())
        {
            p = s.top();
            cout << p->data << " ";        //第二次遇见的时候输出
            s.pop();
            p = p->rchild;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
三、后序遍历
1、递归实现
遍历过程为：

后序遍历其左子树；
后序遍历其右子树；
访问根结点。
void postOrderTraverse(BiTree pRoot)
{
    if (pRoot == NULL)
        return;
    postOrderTraverse(pRoot->lchild);
    postOrderTraverse(pRoot->rchild);
    cout << pRoot->data<<" ";
}
1
2
3
4
5
6
7
8
2、非递归实现
第一种思路：对于任一结点P，将其入栈，然后沿其左子树一直往下搜索，直到搜索到没有左孩子的结点，此时该结点出现在栈顶，但是此时不能将其出栈并访问， 因此其右孩子还为被访问。所以接下来按照相同的规则对其右子树进行相同的处理，当访问完其右孩子时，该结点又出现在栈顶，此时可以将其出栈并访问。这样就 保证了正确的访问顺序。可以看出，在这个过程中，每个结点都两次出现在栈顶，只有在第二次出现在栈顶时，才能访问它。因此需要多设置一个变量标识该结点是 否是第一次出现在栈顶。

typedef struct Node
{
    BiTree btnode;
    bool isfirst;
}Node,*node;

void postOrder(BiTree pRoot)
{
    if (pRoot == NULL)
        return;
    stack<node>s;
    BiTree p = pRoot;
    node tmp;
    while (p!=NULL || !s.empty())
    {
        while (p != NULL)            //沿左子树一直往下搜索，直至出现没有左子树的结点
        {
            node btn = (node)malloc(sizeof(Node));
            btn->btnode = p;
            btn->isfirst = true;
            s.push(btn);
            p = p->lchild;
        }
        if (!s.empty())
        {
            tmp = s.top();
            s.pop();
            if (tmp->isfirst == true)    //第一次出现在栈顶
            {
                tmp->isfirst = false;
                s.push(tmp);
                p = tmp->btnode->rchild;
            }
            else                //第二次出现在栈顶
            {
                cout << tmp->btnode->data<<" ";
                p = NULL;
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
第二种思路：要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了 每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。

void postorder(BiTree pRoot)
{
    if (pRoot == NULL)
        return;
    stack<BiTree>s;
    BiTree cur = pRoot, pre = NULL;
    s.push(pRoot);
    while (!s.empty())
    {
        cur = s.top();
        if ((cur->lchild == NULL&&cur->rchild == NULL) ||
            ((pre == cur->lchild || pre == cur->rchild) && pre != NULL))
        {
            cout << cur->data << " ";
            s.pop();
            pre = cur;
        }
        else
        {
            if (cur->rchild != NULL)
                s.push(cur->rchild);
            if (cur->lchild != NULL)
                s.push(cur->lchild);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
四、c++完整代码
#include<iostream>
#include<stdlib.h>
#include<stack>
using namespace std;
#define len 15                        //定义一个长度

typedef int ElemType;

typedef struct BiTNode
{
    ElemType data;
    struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

typedef struct Node
{
    BiTree btnode;
    bool isfirst;
}Node,*node;

//向下遍历，找到节点s应该插入的位置，节点有重复时，忽略这个节点
void SearchTreeNode(BiTree &root, BiTree &s)    //注意：使用引用传递
{
    if (root == NULL)
        return;
    if (s->data > root->data)
    {
        if (root->rchild == NULL)
        {
            root->rchild = s;
            return;
        }
        SearchTreeNode(root->rchild, s);//s值大于根节点值，未到达叶子节点，继续向右孩子遍历
    }

    else if (s->data < root->data)
    {
        if (root->lchild == NULL)
        {
            root->lchild = s;
            return;
        }
        SearchTreeNode(root->lchild, s);//s值小于根节点值，未到达叶子节点，继续向左孩子遍历
    }
}

//插入一个节点，树为空，插入节点即为根节点，否则找合适的位置插入
void InsertNode(BiTree &tree, BiTree &s)        //注意：使用引用传递
{
    if (tree == NULL)
        tree = s;
    else
        SearchTreeNode(tree, s);
}

//二叉排序树创建，每次增加一个结点，插到现有的二叉树上去
void CreateOrderBinaryTree(BiTree &tree, int *a)
{
    for (int i = 0; i < len; i++)
    {
        BiTree s = (BiTree)malloc(sizeof(BiTNode));
        s->data = a[i];
        s->lchild = NULL;
        s->rchild = NULL;
        InsertNode(tree, s);
    }
}
//前序遍历
void ProOrderTraverse(BiTree tree)
{
    if (tree == NULL)
        return;
    cout << tree->data << " ";
    ProOrderTraverse(tree->lchild);
    ProOrderTraverse(tree->rchild);
}
//非递归前序遍历
void ProOrder(BiTree pRoot)
{
    if (pRoot == NULL)
        return;
    BiTree p = pRoot;
    stack<BiTree>s;

    while (p != NULL || !s.empty())
    {
        while (p != NULL)
        {
            s.push(p);
            cout << p->data << " ";        //第一次遇见的时候输出
            p = p->lchild;
        }
        if (!s.empty())
        {
            p = s.top();
            s.pop();
            p = p->rchild;
        }
    }
}

//中序遍历
void midOrderTraverse(BiTree tree)
{
    if (tree == NULL)
        return;
    midOrderTraverse(tree->lchild);
    cout << tree->data << " ";
    midOrderTraverse(tree->rchild);
}

//非递归中序遍历
void midOrder(BiTree pRoot)
{
    if (pRoot == NULL)
        return;
    BiTree p = pRoot;
    stack<BiTree>s;
    while (p != NULL || !s.empty())
    {
        while (p!=NULL)
        {
            s.push(p);
            p = p->lchild;
        }
        if (!s.empty())
        {
            p = s.top();
            cout << p->data << " ";        //第二次遇见的时候输出
            s.pop();
            p = p->rchild;
        }
    }
}

//后序遍历
void postOrderTraverse(BiTree pRoot)
{
    if (pRoot == NULL)
        return;
    postOrderTraverse(pRoot->lchild);
    postOrderTraverse(pRoot->rchild);
    cout << pRoot->data<<" ";
}

//非递归实现后续遍历
void postOrder(BiTree pRoot)
{
    if (pRoot == NULL)
        return;
    stack<node>s;
    BiTree p = pRoot;
    node tmp;
    while (p!=NULL || !s.empty())
    {
        while (p != NULL)        //沿左子树一直往下搜索，直至出现没有左子树的结点
        {
            node btn = (node)malloc(sizeof(Node));
            btn->btnode = p;
            btn->isfirst = true;
            s.push(btn);
            p = p->lchild;
        }
        if (!s.empty())
        {
            tmp = s.top();
            s.pop();
            if (tmp->isfirst == true)            //第一次出现在栈顶
            {
                tmp->isfirst = false;
                s.push(tmp);
                p = tmp->btnode->rchild;
            }
            else                        //第二次出现在栈顶
            {
                cout << tmp->btnode->data<<" ";
                p = NULL;
            }
        }
    }
}

//非递归实现后续遍历
void postorder(BiTree pRoot)
{
    if (pRoot == NULL)
        return;
    stack<BiTree>s;
    BiTree cur = pRoot, pre = NULL;
    s.push(pRoot);
    while (!s.empty())
    {
        cur = s.top();
        if ((cur->lchild == NULL&&cur->rchild == NULL) ||
            ((pre == cur->lchild || pre == cur->rchild) && pre != NULL))
        {
            cout << cur->data << " ";
            s.pop();
            pre = cur;
        }
        else
        {
            if (cur->rchild != NULL)
                s.push(cur->rchild);
            if (cur->lchild != NULL)
                s.push(cur->lchild);
        }
    }
}

int main()
{
    int a[len] = { 62, 88, 58, 47, 35, 73, 51, 99, 37, 93, 23, 27, 45, 21, 12 };

    BiTree tree = NULL;
    //创建一个二叉树，并中序遍历
    CreateOrderBinaryTree(tree, a);

    cout << "前序遍历" << endl;
    ProOrderTraverse(tree);
    cout << endl;
    ProOrder(tree);
    cout << endl<<endl;

    cout << "中序遍历" << endl;
    midOrderTraverse(tree);
    cout << endl;
    midOrder(tree);
    cout << endl<<endl;

    cout << "后序遍历" << endl;
    postOrderTraverse(tree);
    cout << endl;
    postOrder(tree);
    cout << endl;
    postorder(tree);
    cout << endl<<endl;

    return 0;
}
 

二叉树的递归与非递归遍历：C++实现
weixin_72391681的博客
08-16 580
学会用递归与非递归的方式学会遍历二叉树，非递归实现遍历二叉树的本质是模拟系统递归栈。
二叉树非递归遍历（C++）
最新发布
lim6ere的博客
06-03 1417
我们之前学习过用递归解决二叉树的前序，中序，后序。下面我们将用非递归，也就是遍历的方法对二叉树进行遍历以上就是今天要讲的内容，本文仅仅详细介绍了二叉树前序，中序，后序三种非递归遍历方式。希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~ 😘 😘 😘。
C++ 二叉树遍历（非递归版）
07-26
二叉树几种遍历方式的非递归版本 先序遍历 中序遍历 后序遍历 层次遍历
二叉树遍历非递归实现
程序猿的挨踢人生
03-24 2432
遍历是二叉树各种操作的基础，上一节给出的遍历算法是递归实现的，本节给出二叉树遍历的非递归实现，非递归实现需要使用前面讲到的数据结构——栈、队列来作为辅助空间
二叉树(2)——遍历的非递归实现
专注于此刻
06-12 221
算法概述 递归算法简洁明了、可读性好，但与非递归算法相比要消耗更多的时间和存储空间。为提高效率，我们可采用一种非递归的二叉树遍历算法。非递归的实现要借助栈来实现，因为堆栈的先进后出的结构和递归很相似。 对于中序遍历来说，非递归的算法比递归算法的效率要高的多。其中序遍历算法的实现的过程如下： (1).初始化栈，根结点进栈； (2).若栈非空，则栈顶结点的左孩子结点相继进栈，直到nul...
二叉树非递归遍历(C++版本)
liutianjia2014的博客
06-30 588
二叉树非递归遍历有三种方式：前序遍历、中序遍历、后续遍历 前序遍历 class Solution { public: vector preorderTraversal(TreeNode* root) { vector res; stack s; while (root || !s.empty()){
二叉树遍历的c++实现（递归和非递归深度优先遍历）
09-13
深度优先遍历的实现； 广度优先遍历的实现；
二叉树的非递归遍历 C/C++
feel_myself_is_lowB的博客
06-28 376
前面用递归的方式实现了二叉树的遍历：https://blog.youkuaiyun.com/feel_myself_is_lowB/article/details/106897311 下面用非递归方式实现二叉树遍历：
二叉树的非递归遍历
10-20
二叉树的非递归遍历，使用C++实现二叉树的非递归遍历，对正在学习算法的同学应该挺有帮助的
非递归遍历二叉树---c++写法
m0_53157173的博客
03-15 455
前序遍历的非递归算法 #include<iostream> using namespace std; #include<stack> struct node { char data; node* lchild; node* rchild; }; //树的建立---前序建立 void creatTree(char ch[10],node*& root) { static int i = 0; if (ch[i] == '#') { i++; root
二叉树的非递归遍历（c/c++）
Little_ant_的博客
02-09 2370
二叉树的非递归遍历分为三种：先序非递归遍历，中序非递归遍历和后续非递归遍历。这和递归遍历的结果是一样的，区别只是在于采用了循环结构。 先序非递归遍历 采用辅助数据结构栈来实现，先序遍历是按照先根，后左子树，再右子树的顺序进行递归访问的。由于栈是先入后出的，所以入栈顺序为先右孩子后左孩子。 非递归的算法是先将根结点入栈，栈不为空时：根结点出栈并访问，然后将右孩子入栈，再将左孩子入栈；左孩子出栈并访问...
“非递归” 实现二叉树的“前序、中序、后序、层序”遍历
CYK_byte的博客
03-15 3071
相信学过或是了解过二叉树的朋友都知道，他的前序、中序、后序遍历使用递归法实现非常简单，那么如果使用非递归的方式来解，也就是使用迭代来解，你还能将他拿下么？实际上一点都不难，往下看~
c语言和c++实现二叉树非递归遍历
hou19975418的博客
01-18 647
结合栈结构来实现二叉树的非递归遍历，首先将根节点入栈，然后对栈内元素进行循环，弹出栈顶元素，根据链表结点携带的标志位flag来判断是对于结点进行打印还是后续的入栈操作。入栈顺序决定着实际的遍历方式。
递归非递归实现树的遍历
cxh342968816的专栏
08-05 931
1.先序遍历 从递归说起 void preOrder(TNode* root){    if (root != NULL)    {        Visit(root);        preOrder(root->left);        preOrder(ro
二叉树非递归遍历
yue152152的博客
07-29 1535
带你理解二叉树的非递归遍历
c++练习(5):二叉树非递归遍历
@bangbang的博客
07-23 983
判断top是否为NULL不是NULL，按顺序右左跟如果是NULL,说明是要杀的驴1.将NULL（top）pop掉2.将新的top（栈元素）pop3.将top中的val放到vector容器中这就是完整的二叉树非递归遍历的顺序。httpshttpshttpshttpshttpshttpshttpshttps。...
C++实现二叉树的非递归遍历
qq_41696018的博客
08-23 1879
在前面C++实现二叉树的递归遍历(详细步骤与代码实现)我们实现二叉树通过递归遍历实现了先序、中序与后续遍历，那么如何通过非递归遍历实现先序、中序与后续遍历呢？我们先看看非递归遍历规则。 还是同样的二叉树 1、首先将二叉树根节点A放入栈中，并将节点是否打印标签设为false。 2、再将节点A从栈中弹出，将其左右子树节点BF入栈，打印标签设为false，将A再次入栈，此时是否打印的标签设为true（注意这里三个节点入栈顺序与先序、中序与后续遍历方式有关,入栈顺序与遍历顺序正好相反，...
C++非递归实现二叉树构建与遍历
非递归实现二叉树的建立和遍历，虽然在初期编写时可能比较复杂，但其算法性能稳定，且没有递归可能导致的栈溢出问题。使用栈进行迭代遍历，尤其是中序遍历，可以非常有效地解决问题。在实际应用中，掌握非递归的遍历...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值