二叉树的遍历（非递归，stack）{未完待续........}

最新推荐文章于 2022-03-23 20:55:22 发布
最新推荐文章于 2022-03-23 20:55:22 发布
阅读量239 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 二叉树（非递归）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43237242/article/details/89161947
版权

二叉树的遍历（递归），请参考该篇博客：二叉树的简单操作（递归实现）


这里有一篇很好的博客分享：二叉树前序、中序、后序遍历非递归写法的透彻解析

下面让我们看看非递归朝作，考虑到由于用C语言写的话 要自己用链表模拟栈，，，所以，此处改为C++代码了。。因为，可以直接调用STL中的stack。。。。。。

//#include<bits/stdc++.h>
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
#include<string>
#include<math.h>
#include<stack>;			//stack的头文件
using namespace std ;
typedef long long ll;
#define MAXN 100005
#define INF 0x3f3f3f3f
#define MALL (BiTnode *)malloc(sizeof(BiTnode));

typedef  struct BiTnode
{
    int data;//当然，你这里可以放你想要的数据
    struct BiTnode *lchild, *rchild;
}BiTnode, *Bitree;

先序遍历：

首先，我们遍历左子树，边遍历边打印，并把根节点存入栈中，以后需借助这些节点进入右子树开启新一轮的循环。还得重复一句：所有的节点都可看做是根节点。
接下来就是：出栈，根据栈顶节点进入右子树。

void stackfirst_one(Bitree T)
{
    if(T == NULL)
        return;
    Bitree p = T;
    stack<Bitree>st;
    while(p || !st.empty())
    {
   //边遍历边打印，并存入栈中，以后需要借助这些根节点(不要怀疑这种说法哦)进入右子树
        while(p)
        {
            st.push(p);
            cout << p->data;
            p = p->lchild;
        }
    //当p为空时，说明根和左子树都遍历完了，该进入右子树了
        if(!st.empty())
        {
            p = st.top();
            st.pop();
            p = p->rchild;
        }
    }
    cout << '\n';
}

当然，书上可不是这样的：

void stackfirst_two(Bitree T)
{
    if(T == NULL)
        return ;
    Bitree p = T;
    stack<Bitree> st;
    while(p || !st.empty())
    {
        if(p)
        {
            cout << p->data;
            st.push(p);
            p = p->lchild;
        }
        else
        {
            p = st.top();
            st.pop();
            p = p->rchild;
        }
    }
    cout << '\n';
}


中序遍历。。。。

遇到一个结点，就把它压栈，并去遍历它的左子树；
当左子树遍历结束后，从栈顶弹出这个结点并访问它；
然后按其右指针再去中序遍历该结点的右子树。

void stackmiddle_one(Bitree T)
{
    if(T == NULL)
        return ;
    Bitree p = T;
    stack<Bitree>st;
    while(p || !st.empty())
    {
       //一直遍历到左子树最下边，边遍历边保存根节点到栈中
        while(p)
        {
            st.push(p);
            p = p->lchild;
        }
      //当p为空时，说明已经到达左子树最下边，这时需要出栈了
        if(!st.empty())
        {
            p = st.top();
            st.pop();
            cout << p->data;
          //进入右子树，开始新的一轮左子树遍历(这是递归的自我实现)
            p = p->rchild;
        }
    }
    cout << '\n';
}

当然，数据结构上是这样的：

void stackmiddle_two(Bitree T)
{
        if(T == NULL)
            return ;
        Bitree p = T;
        stack<Bitree>st;
        while(p || !st.empty())
        {
            if(p)
            {
                st.push(p);
                p = p->lchild;
            }
            else
            {
                p = st.top();
                st.pop();
                cout << p->data;
                p = p->rchild;
            }
        }
        cout << '\n';
}
层次遍历（队列）

思路：
1、若根节点为空，直接返回；
2、若根节点非空，则将根节点入队，然后判断其左右子节点是否为空，若不为空，则压入队列。此时将根结点打印输出，并将根结点出队列。依次循环执行，直到队列为空。

void cenci(Bitree T)
{
    if(T == NULL)
        return;
    queue<Bitree> que;
    que.push(T);		
    while(!que.empty())
    {
        Bitree p = que.front();
        cout << p->data << ' ';
        que.pop();

        if(p->lchild!=NULL)
            que.push(p->lchild);
        if(p->rchild!=NULL)
            que.push(p->rchild);
    }
    cout << '\n';
}

总代码：

//#include<bits/stdc++.h>
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
#include<string>
#include<math.h>
#include<stack>;
using namespace std ;
typedef long long ll;
#define MAXN 100005
#define INF 0x3f3f3f3f
#define MALL (BiTnode *)malloc(sizeof(BiTnode));

typedef  struct BiTnode
{
    char data;
    struct BiTnode *lchild, *rchild;
} BiTnode, *Bitree;

void stackfirst_one(Bitree T)
{
    if(T == NULL)
        return;
    Bitree p = T;
    stack<Bitree>st;
    while(p || !st.empty())
    {
   //边遍历边打印，并存入栈中，以后需要借助这些根节点(不要怀疑这种说法哦)进入右子树
        while(p)
        {
            st.push(p);
            cout << p->data;
            p = p->lchild;
        }
    //当p为空时，说明根和左子树都遍历完了，该进入右子树了
        if(!st.empty())
        {
            p = st.top();
            st.pop();
            p = p->rchild;
        }
    }
    cout << '\n';
}

void stackfirst_two(Bitree T)
{
    if(T == NULL)
        return ;
    Bitree p = T;
    stack<Bitree> st;
    while(p || !st.empty())
    {
        if(p)
        {
            cout << p->data;
            st.push(p);
            p = p->lchild;
        }
        else
        {
            p = st.top();
            st.pop();
            p = p->rchild;
        }
    }
    cout << '\n';
}

void stackmiddle_one(Bitree T)
{
    if(T == NULL)
        return ;
    Bitree p = T;
    stack<Bitree>st;
    while(p || !st.empty())
    {
       //一直遍历到左子树最下边，边遍历边保存根节点到栈中
        while(p)
        {
            st.push(p);
            p = p->lchild;
        }
      //当p为空时，说明已经到达左子树最下边，这时需要出栈了
        if(!st.empty())
        {
            p = st.top();
            st.pop();
            cout << p->data;
          //进入右子树，开始新的一轮左子树遍历(这是递归的自我实现)
            p = p->rchild;
        }
    }
    cout << '\n';
}

void stackmiddle_two(Bitree T)
{
        if(T == NULL)
            return ;
        Bitree p = T;
        stack<Bitree>st;
        while(p || !st.empty())
        {
            if(p)
            {
                st.push(p);
                p = p->lchild;
            }
            else
            {
                p = st.top();
                st.pop();
                cout << p->data;
                p = p->rchild;
            }
        }
        cout << '\n';
}

void first(Bitree T)
{
    if(T)
    {
        cout << T->data;//这里你可以选择保存数据，，，
        first(T->lchild);
        first(T->rchild);
    }
}

void middle(Bitree T)
{
    if(T)
    {
        middle(T->lchild);
        cout << T->data;//这里你可以选择保存数据，，，
        middle(T->rchild);
    }
}

void END(Bitree T)
{
    if(T)
    {
        END(T->lchild);
        END(T->rchild);
        cout << T->data;
    }
}

Bitree CreatBitree(Bitree &T)
{
    char ch;
    cin >> ch;
    if(ch == '#')//若ch为 # ，则二叉树为空树。
        T = NULL;
    else
    {
        T = (BiTnode *)malloc(sizeof(BiTnode));
        T->data = ch;
        CreatBitree(T->lchild);//递归先序创建左子树
        CreatBitree(T->rchild);//递归先序创建右子树
    }
    return T;
}

void Copy(Bitree T, Bitree &newT)//复制二叉树
{
    if(T == NULL)
    {
        newT = NULL;
        return ;
    }
    else
    {
        newT = (BiTnode *)malloc(sizeof(BiTnode));
        newT->data = T->data;
        Copy(T->lchild, newT->lchild);
        Copy(T->rchild, newT->rchild);
    }
}

int depth(Bitree T)//查询二叉树的深度
{
    int m, n;
    if(T == NULL)
        return 0;
    else
    {
        m = depth(T->lchild);
        n = depth(T->rchild);
        return m>n ? m+1 : n+1;
    }
}

int Nodecount(Bitree T)//二叉树的总结点数
{
    if(T == NULL)//如果是空树，则结点个数为0，递归结束
        return 0;
    else
        return Nodecount(T->lchild)+Nodecount(T->rchild)+1;
    // 否则结点个数为左子树的结点个数+右子树的结点个数+1（根结点）
}

int yezi(Bitree T)//求二叉树的叶子数/。。
{
    if(T == NULL)
        return 0;
    else if(T->lchild == NULL && T->rchild == NULL)//左右为空，证明的叶子结点，返回1.
        return 1;
    else
        return yezi(T->lchild)+yezi(T->rchild);
}

int main()
{
    Bitree T;
    T = CreatBitree(T);
    int x = depth(T), y = Nodecount(T), z = yezi(T);
    cout << "该二叉树的深度为：" << x << '\n';
    cout << "该二叉树的结点数为：" << y << '\n';
    cout << "该二叉树的叶子数为：" << z << '\n' << '\n';


    cout << "先序遍历的结果为：" << '\n';
    first(T); cout << '\n';
    stackfirst_one(T);
    stackfirst_two(T);

    cout << "中序遍历的结果为：" << '\n';
    middle(T); cout << '\n';
    stackmiddle_one(T);
    stackmiddle_two(T);

    cout << "后序遍历的结果为：" << '\n';
    END(T); cout << '\n';

    return 0;
}
浦柳人
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树的遍历----递归与非递归
可可狸的博客
11-03 321
package com.Tree; import java.util.Stack; import java.util.Queue; import java.util.LinkedList; /* * 三种递归遍历方法 * 四种非递归遍历方法 */ public class Traverse { //递归先序遍历 public void recPreOrder(BTNode root)
二叉树之遍历系列
StackOverflow的博客
10-13 89
1.二叉树的中序遍历 Leetcode 94；medium； 遍历系列常使用，最好能掌握迭代和递归方法！ package tree; import java.util.ArrayList; import java.util.List; import java.util.Stack; public class Main0094二叉树的中序遍历 { public static void main...
二叉树的各种遍历
yangchuang93的博客
08-29 425
摘自 Charles_ke   #include&lt;iostream&gt; #include&lt;stack&gt; #include&lt;queue&gt; using namespace std; //节点结构体 struct Node { int value; Node * left; Node * right; Node(int value)...
Day04 二叉树的四种遍历(灵活使用Queue、Stack、ArrayList)
qq_31842777的博客
05-20 492
转载注明！ 菜鸟入门，望指正 二叉树有四种遍历方式，即层序遍历、前序遍历、中序遍历、后序遍历。每种遍历都有两种实现方式：递归算法和非递归算法，不同的遍历方式的实现涉及的数据机构不同，主要会用到Queue、Stack、ArrayList。 下面给出各种遍历方式的具体实现及测试。 学习推荐 import java.util.ArrayList; import java.util.LinkedList;...
非递归学习树结构（一）--栈和队列的实现
N_sev7的Blog
09-16 1202
在开始学习树结构之前，有必要先学习一下栈和队列的知识，我们知道，在树结构中最让人头疼的就是各种递归，据传言，所有的递归都可以用栈来实现，因为递归的过程其实就是进栈出栈的过程，因此，可以把递归改写成对栈的迭代操作，对于是递归好还是迭代好这样的讨论我们就不复述了，没有最好，只有最合适。 栈和队列是学习树结构之前应该掌握的知识，我们知道树有前中后序遍历，深广优先搜索，如果树的遍历中使用递归方法，则涉及
erchashu.rar_二叉树 遍历 非递归
09-22
二叉树遍历是针对这种数据结构进行操作的重要算法，它包括三种基本的递归遍历方法：先序遍历、中序遍历和后序遍历，以及一种非递归的层次遍历方法。这里我们将深入探讨这些非递归遍历的方法。 **非递归先序遍历** ...
二叉树的后序遍历非递归算法.doc
05-07
"二叉树的后序遍历非递归算法" 本文档主要介绍了二叉树的后序遍历非递归算法，该算法的实现可以有效地避免递归函数的使用，提高了算法的效率。该算法的实现主要基于栈的使用，将结点入栈和出栈来实现后序遍历。 ...
二叉树的非递归遍历c.pdf
最新发布
11-15
二叉树的非递归遍历是数据结构与算法领域中的一个重要话题，它涉及到对二叉树节点的顺序访问，而无需使用递归方法。在给定的代码中，使用了C语言实现了二叉树的前序、中序和后序非递归遍历。这些遍历方式通常用于...
遍历二叉树递归+非递归实验报告.doc
10-10
在实验中，我们定义了二叉树构造体类型时，也定义了一个顺序栈构造体类型，用以辅助完成二叉树的非递归遍历。我们从键盘输入二叉树先序序列，用扩展线序序列函数承受并创立二叉链表。在遍历前，我们先判断二叉树是否...
二叉树遍历的递归算法.py
11-29
二叉树遍历的递归算法.py
stack 实现二叉树的非递归遍历——C语言
柯惟的博客
09-23 1233
栈 二叉树 非递归遍历 stack.h#ifndef STACK_H #define STACK_H #include"BinaryTree.h"#define STACKSIZE 100 typedef BtNode * StackType; typedef struct //定义栈结构 { StackType * data; //存放结点的地址 int top;
二叉树的遍历
蒻菜_羊羊羊的专栏
12-22 501
#include #include #include using namespace std; //二叉树结点 typedef struct BiTNode{ //数据 char data; //左右孩子指针 struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; //按先序序列创建二叉树 int CreateBiTree(BiTree &T
c++ stack 遍历_python实现二叉树的遍历以及其他基本操作
weixin_39654352的博客
11-24 108
主要内容： 二叉树遍历（先序、中序、后序、宽度优先遍历）的迭代实现和递归实现； 二叉树的深度，二叉树到叶子节点的所有路径。首先，先定义二叉树类（python3），代码如下：class 内容1：二叉树的遍历二叉树的遍历分深度优先遍历（DFS）和宽度优先遍历（BFS）。其中深度优先遍历又分为先序遍历，中序遍历，后序遍历。因为二叉树是递归类数据结构，因此大部分关于二叉树的操作都可以通过递归实现。下面将介...
java+stack+for遍历,二叉树的java 实现-创建，遍历
weixin_26899879的博客
03-13 270
import java.util.LinkedList;import java.util.Queue;import java.util.Stack;public class TreeNode {int val;TreeNode left;TreeNode right;TreeNode(int x) { val = x; }public static TreeNode creatBTfromArr(...
按“之“字顺序打印二叉树 (树遍历，stack，queue结合使用)
y2zaijian的博客
07-29 143
树遍历，stack，queue结合使用 请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。 解题思路： 之字形打印，本质也是对树形结构的层序遍历，不过在遍历的过程中，需要更改遍历顺序 采用stack和queue的方式来进行处理 核心思路: 当前层从左向右遍历，那么下层就从left到right入栈，当前层如果从右向左遍历，那么下层就 从right到left入栈 注意: 层序遍历(用queue) 逆序(stack) 栈
stack的应用-树的遍历（先序，中序，后序）
AI R&D
03-23 1713
Stack实现树的非递归遍历（先序 中序 后序）
二叉树的几种遍历方式浅析：递归遍历/堆栈遍历/层序遍历/Morris遍历
懂幸福，爱生活
08-25 4322
递归和堆栈来实现二叉树的遍历
二叉树非递归遍历
qq_36999309的博客
03-07 2412
先序遍历 先序遍历顺序：中左右 首先构造一个栈，将根节点压入栈。然后弹出栈顶部元素，打印输出，再压入弹出元素的右儿子和左儿子（注意顺序）。 这时再开始循环，弹出栈顶元素，打印输出，再压入弹出元素的右儿子和左儿子，直到最后栈元素为空 public void before(Node root) { if(root==null) return; Stack&lt;N...
二叉树的非递归遍历的实现
YG爱木木
12-21 2396
1.前言：当然了，这也是复习。因为数据结构要考试了，把之前的算法拿出来敲一遍。 2.二叉树的遍历是一个基于二叉树很重要的操作，应用也很多。我们知道递归是树的特性，所以树上的所有算法几乎都是基于递归做的。但是在一些嵌入式设备中，系统栈不允许很深的递归。这时候就要把递归的算法转换为非递归算法，嗯，没错，应用场景看上去有点实际，但是真正促使我的还是考试，哈哈。 先给出一个遍历的递归算法把。 ty...
二叉树遍历：递归与非递归实现
此外，文件中还提到了二叉树节点的栈和队列表示，这在非递归遍历或树的其他操作中非常有用。栈用于后序遍历的非递归实现，而队列常用于层次遍历（Level Order Traversal），即按照从上到下、从左到右的顺序访问所有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值