二叉树的层序遍历+非递归算法（C语言）（联合能力）

最新推荐文章于 2024-07-15 14:06:50 发布
最新推荐文章于 2024-07-15 14:06:50 发布
阅读量2.5w 收藏 48
点赞数 12
分类专栏： 数据结构 文章标签： 队列 数据结构 算法 二叉树 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52290436/article/details/116126419
版权

学校数据结构的题也完成差不多，最近也在考虑博客应该写那些方面。毕竟大学里学习还是以考试为中心，我也就把平时看什么就写出来吧。

二叉树的层序遍历+非递归算法（C语言）

层序遍历

队列用数组实现

层序遍历就是按二叉树一层一层遍历，我认为已经很直观了其实。写这篇博客就是加强我二叉树与栈和队列的联合应用的能力，毕竟学到道理与敲代码出来差距是很大的。

#include<stdio.h>
#include<stdlib.h>

#define MAXSIZE 100
typedef struct Node{
char data;
struct Node *Lchild;
struct Node *Rchild;
}BiTNode,*Bitree;

typedef struct queue{
    BiTNode *numQ[MAXSIZE];//注意此处为关键。我们用的队列要与我们的ADT类型相同！！
    int front;
    int rear;
}Queue;//在这里我选择用数组来操作



void CreateBinTree(BiTNode **T)
{
    char ch;
    ch=getchar();
   if(ch=='#'){ *T=NULL;return;}

            *T=(BiTNode*)malloc(sizeof(BiTNode));
            (*T)->data=ch;
        CreateBinTree(&((*T)->Lchild));
        CreateBinTree(&((*T)->Rchild));
}
void PreTree(Bitree T)
{   if(T==NULL) return;
    printf("%c ",T->data);
     PreTree(T->Lchild);
     PreTree(T->Rchild);

}


//以下为建立队列的基本操作，注意与二叉树对应
void initilize(Queue *Q) { //初始化队列
    Q->front = 0;
    Q->rear = 0;
}

void Push(Queue *Q,BiTNode *T)//入队
//我还是比较喜欢用带*的来表示指针，比较直观
{
    Q->rear++;
    Q->numQ[Q->rear]=T;
}

BiTNode *Pop(Queue *Q)//出队
{
    Q->front++;
    return Q->numQ[Q->front];
}

int Isempty(Queue *Q)//判断是否为空
{
    return Q->front==Q->rear;
}

void LayerOrder(BiTNode *T)//二叉树的层次遍历
{
    Queue Q;
    initilize(&Q);
    BiTNode *p;
    Push(&Q,T);
    while(!Isempty(&Q))
    {
        p=Pop(&Q);
        printf("%c ",p->data);//输出队首结点
        if(p->Lchild) Push(&Q,p->Lchild);//把Pop掉的结点的左子结点加入队列
        if(p->Rchild) Push(&Q,p->Rchild);//把Pop掉的结点的右子结点加入队列
    }


}
int main()
{
    BiTNode *T=(BiTNode*)malloc(sizeof(BiTNode));
    CreateBinTree(&T);
    //PreTree(T);
    LayerOrder(T);
    return 0;
}

这就完事了，如图：

在这里插入图片描述
在这里插入图片描述
（灵魂画师）
这里最后可以不在 LayerOrder中建立队列，可以在主函数中建立，调用时就不用加&了，如下代码：
（变化仅仅在最后两个函数，读者有兴趣可以粘贴试一试）

void LayerOrder(Queue *Q,BiTNode *T)//二叉树的层次遍历
{

    BiTNode *p;
    Push(Q,T);
    while(!Isempty(Q))
    {
        p=Pop(Q);
        printf("%c ",p->data);//输出队首结点
        if(p->Lchild) Push(Q,p->Lchild);//把Pop掉的结点的左子结点加入队列
        if(p->Rchild) Push(Q,p->Rchild);//把Pop掉的结点的右子结点加入队列
    }


}
int main()
{
    BiTNode *T=(BiTNode*)malloc(sizeof(BiTNode));
    CreateBinTree(&T);
    Queue Q;
    initilize(&Q);
    //PreTree(T);
    LayerOrder(&Q,T);
    return 0;
}

或者，完全可以定义全局变量，这样就根本不用在函数调用Q，用的时候直接用" . “来访问，不用“->”，不失为一种好方法。

这里最关键为建立队列时建立的数组为BitTreeNode * 类型的，要相对应。

用链队列实现

#include<stdio.h>
#include<stdlib.h>

#define MAXSIZE 100

typedef struct TreeNode{
char data;
struct TreeNode *Lchild;
struct TreeNode *Rchild;
}BiTNode,*Bitree;

typedef BiTNode* QueueElemType;//终于懂了啥叫用户自定义类型了

typedef struct Node
{
    QueueElemType data;
    struct Node *next;
}LQNode;

typedef struct {
LQNode *front;
LQNode *near;
}LinkQueue;

void CreateBinTree(BiTNode **T)
{
    char ch;
    ch=getchar();
   if(ch=='#'){ *T=NULL;return;}

            *T=(BiTNode*)malloc(sizeof(BiTNode));
            (*T)->data=ch;
        CreateBinTree(&((*T)->Lchild));
        CreateBinTree(&((*T)->Rchild));
}
void PreTree(Bitree T)
{   if(T==NULL) return;
    printf("%c ",T->data);
     PreTree(T->Lchild);
     PreTree(T->Rchild);
}

//以下为建立链队列的基本操作，注意与二叉树对应

void initilize(LinkQueue *Q) { //初始化队列
     Q->front=(LQNode*)malloc(sizeof(LQNode));
     Q->near=Q->front;
    Q->front->next=NULL;
}


void EnterQueue(LinkQueue *Q,BiTNode *x)//入队
{
    LQNode *NewNode;
    NewNode=(LQNode*)malloc(sizeof(LQNode));

    if(NewNode!=NULL)
    {
        NewNode->data=x;
        NewNode->next=NULL;
        Q->near->next=NewNode;
        Q->near=NewNode;
    }
}

BiTNode *DeleteQueue(LinkQueue *Q)//出队
{
    LQNode *p;
    p=Q->front->next;
    Q->front->next=p->next;
    if(Q->near==p)  //若只有一个元素
    {
        Q->front=Q->near;
    }

    return p->data;
}

int Isempty(LinkQueue *Q)
{
    return Q->front==Q->near;
}

void LayerOrder(LinkQueue *Q,BiTNode *T)//二叉树的层次遍历
{

    BiTNode *p;
    EnterQueue(Q,T);
    while(!Isempty(Q))
    {
        p=DeleteQueue(Q);
        printf("%c ",p->data);//输出队首结点
        if(p->Lchild) EnterQueue(Q,p->Lchild);//把Pop掉的结点的左子结点加入队列
        if(p->Rchild) EnterQueue(Q,p->Rchild);//把Pop掉的结点的右子结点加入队列
    }
}

int main()
{
    BiTNode *T=(BiTNode*)malloc(sizeof(BiTNode));
    CreateBinTree(&T);
    //PreTree(T);

    LinkQueue *Q=(LinkQueue*)malloc(sizeof(LinkQueue));
    initilize(Q);

    LayerOrder(Q,T);
    return 0;

}

在这里插入图片描述
有一点要注意，就是我在主函数中定义 *Q，需要分配空间才能调用初始化函数进行初始化，若是初始化直接在主函数中进行，则不必须分配Q的空间。
像我在前面用数组队列的时候就是直接定义Q，但这里用指针操作则必须定义 *Q。
我认为这里难懂的是什么时候用&，这里还是平时经验和编译的时候报不报错来判断的。谨记指针即是地址，在函数中调用过地址的变量所代表即是地址。
话说还是数组来的方便，用链队列太麻烦。

非递归算法

中序遍历的非递归算法

模拟栈

这里就是模拟压栈操作进行模拟递归，比较递归本质就是压栈。

#include<stdio.h>
#include<stdlib.h>

#define MAXSIZE 100

typedef struct TreeNode{
char data;
struct TreeNode *Lchild;
struct TreeNode *Rchild;
}BiTNode,*Bitree;

void CreateBinTree(BiTNode **T)
{
    char ch;
    ch=getchar();
   if(ch=='#'){ *T=NULL;return;}

            *T=(BiTNode*)malloc(sizeof(BiTNode));
            (*T)->data=ch;
        CreateBinTree(&((*T)->Lchild));
        CreateBinTree(&((*T)->Rchild));
}

void PreTree(Bitree T)//中序输出
{   if(T==NULL) return;

     PreTree(T->Lchild);
      printf("%c ",T->data);
     PreTree(T->Rchild);

}
void inorder(BiTNode *T)//中序输出非递归
{
    BiTNode *s[MAXSIZE];//模拟栈
    int top=0;
    BiTNode *p;
    p=T;
    do{
        while(p!=NULL)
        {
            if(top>MAXSIZE) return ;
            top++;
            s[top]=p;
            p=p->Lchild;
        }//遍历左子树
        if(top!=0)
        {
            p=s[top];
            top--;
            printf("%c ",p->data);//访问根结点
            p=p->Rchild;//遍历右子树
        }
    }while(p!=NULL||top!=0);
}
int main()
{
    BiTNode *T=(BiTNode*)malloc(sizeof(BiTNode));
    CreateBinTree(&T);
    PreTree(T);
    printf("\n");
    inorder(T);

    return 0;
}

如图可验证正确性：
在这里插入图片描述

调用栈操作

#include<stdio.h>
#include<stdlib.h>

#define MAXSIZE 100

typedef struct TreeNode{
char data;
struct TreeNode *Lchild;
struct TreeNode *Rchild;
}BiTNode,*Bitree;

typedef struct stack
{
    BiTNode *s[MAXSIZE];
    int top;
}Stack;

void CreateBinTree(BiTNode **T)
{
    char ch;
    ch=getchar();
   if(ch=='#'){ *T=NULL;return;}

            *T=(BiTNode*)malloc(sizeof(BiTNode));
            (*T)->data=ch;
        CreateBinTree(&((*T)->Lchild));
        CreateBinTree(&((*T)->Rchild));
}

void PreTree(Bitree T)//中序输出
{   if(T==NULL) return;

     PreTree(T->Lchild);
      printf("%c ",T->data);
     PreTree(T->Rchild);

}
void inorder(BiTNode *T)//中序输出非递归
{
    BiTNode *s[MAXSIZE];//模拟栈
    int top=0;
    BiTNode *p;
    p=T;
    do{
        while(p!=NULL)
        {
            if(top>MAXSIZE) return ;
            top++;
            s[top]=p;
            p=p->Lchild;
        }//遍历左子树
        if(top!=0)
        {
            p=s[top];
            top--;
            printf("%c ",p->data);//访问根结点
            p=p->Rchild;//遍历右子树
        }
    }while(p!=NULL||top!=0);
}
//以下为建立栈的基本操作，注意与二叉树对应
void InitStack(Stack *S)//初始化
{
    S->top=0;
}

void Push(Stack *S,BiTNode *T)//压栈
{
    S->top++;
    S->s[S->top]=T;
}

BiTNode *Pop(Stack *S)//出栈
{
    BiTNode *p;
    p=S->s[S->top];
    S->top--;
    return p;
}

int Isempty(Stack *S)
{
    if(S->top==0) return 1;
    else return 0;
}
void inordermoder2(BiTNode *T)
{
    Stack S;
    InitStack(&S);
    BiTNode *p;
    p=T;
    while(p!=NULL||!Isempty(&S))
    {
        if(p!=NULL)//遍历左子树
        {
            Push(&S,p);
            p=p->Lchild;
            printf("0");
        }
        else{
                 printf("1");
            p=Pop(&S);
            printf("%c ",p->data);
            p-p->Rchild;
        }
    }

}

int main()
{
    BiTNode *T=(BiTNode*)malloc(sizeof(BiTNode));
    CreateBinTree(&T);
    PreTree(T);
    printf("\n");
    inordermoder2(T);

    return 0;
}

建完队列再建栈发现真简单。

后序遍历非递归

//以下为建立栈的基本操作，注意与二叉树对应
void InitStack(Stack *S)//初始化
{
    S->top=0;
}

void Push(Stack *S,BiTNode *T)//压栈
{
    S->top++;
    S->s[S->top]=T;
}

BiTNode *Pop(Stack *S)//出栈
{
    BiTNode *p;
    p=S->s[S->top];
    S->top--;
    return p;
}
void gettop(Stack *S,BiTNode **T)//取栈头
//注意修改树一律用二级指针
{
    (*T)=S->s[S->top];
}

int Isempty(Stack *S)
{
    if(S->top==0) return 1;
    else return 0;
}
void inordermoder2(BiTNode *T)
{
    Stack S;
    InitStack(&S);
    BiTNode *p;
    p=T;
   while(p!=NULL||!Isempty(&S))
    {
        if(p!=NULL)//遍历左子树
        {
            Push(&S,p);
            p=p->Lchild;
            printf("0");
        }
        else{
                 printf("1");
            p=Pop(&S);
            printf("%c ",p->data);
            p-p->Rchild;
        }
    }

}
void PreTree2(Bitree T)//后序输出
{   if(T==NULL) return;

     PreTree(T->Lchild);

     PreTree(T->Rchild);

     printf("%c ",T->data);

}
void PostOrder(BiTNode *T)//后序输出非递归
{
    Stack S;
    BiTNode *q,*p;
    q=NULL;
    p=T;
    InitStack(&S);
    while(p!=NULL||!Isempty(&S))
    {
        if(p!=NULL)
        {
            Push(&S,p);
            p=p->Lchild;
        }//遍历左子树
        else{
                gettop(&S,&p);
                if(p->Rchild==NULL||(p->Rchild==q))
                {
                    printf("%c ",p->data);
                    q=p;
                    p=Pop(&S);
                    p=NULL;
                }
                else{
                    p=p->Rchild;
                }
        }
    }
}

在这里插入图片描述
完事，手打一遍感觉还是有很大收获的。

mcl19909949541
关注
专栏目录
数据结构（十三） -- C语言版 -- 树 - 二叉树的遍历（递归、非递归）
青椒*^_^*凤爪爪的博客
05-23 7885
二叉树是一种非线性的数据结构，在怼他进行操作时，总是需要注意对每个元素进行操作，这样就存在一个操作的顺序的问题，由此提出二叉树的遍历的操作。 所谓二叉树的遍历就是按照一定的顺序访问二叉树的每一个节点一次且仅一次的过程，这里的访问可以是输出、比较、更新、查看元素内容等等操作。
树的非递归遍历算法层次遍历与深度遍历C语言源码
10-22
树的层次遍历与树的的深度遍历，都是用非递归的方法实现的
层次遍历的非递归算法
Jacgu的博客
11-28 1206
层次遍历的非递归算法 上代码（用队列实现） 语言（c++） #include <iostream> #include "btree.h" #include <stdio.h> using namespace std; int main() { BTNode *p,*q; char str[MaxSize],m; printf("\n(1)创建二叉树，请以括号表示法输入二叉树：\n"); gets(str); CreateBTNode(p,st
二叉树---层序遍历（递归与迭代）
最新发布
m0_65096633的博客
07-15 224
使用队列（先进先出）遍历树，队列中存储的节点是一层中的所有节点。初始入队节点root，出队，若左孩子，右孩子不为空，则入队它的左孩子，右孩子。（即逐层地，从左到右访问所有节点）。题目：给你二叉树的根节点。
二叉树的前序，中序，后序遍历（递归）
qq_38522268的博客
07-15 295
二叉树类 public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } 前序： public class Solution { private List<Integer> list=n...
（Java）二叉树的三种遍历（非递归实现）
X_H学Java的博客
11-22 1712
二叉树的三种非递归遍历 非递归前序遍历 非递归中序遍历 非递归后续遍历
<二叉树 前中后 层序 非递归遍历 c语言实现>
yz171329935的专栏
01-29 604
非递归遍历要用到stack，出栈即访问 前序遍历：（中结点->左结点->右节点）  思路：先将根节点入栈，之后进入循环，先出栈一个结点A,  之后如果存在的话，将A的右结点入栈，再将A的左结点入栈，之后继续循环。。这样一直循环到栈空为止。 中序遍历:   （左结点->中结点->右节点） 思路：扫描根节点，将其所有左孩子结点全部入栈， 之后出栈一个结点A，之后再扫描A
c语言实现二叉树的先序，中序，后续遍历（非递归）
blast_dragon的博客
05-16 1721
二叉树的递归遍历很简单，就不详述了。而非递归遍历有一定的难度，所以专门写一篇文章来总结这三种非递归遍历。废话不多说，直接进入正题 在讲非递归遍历之前，先讲一下栈，这是非递归算法的核心思想。 如图： 栈是后进先出，先进后出，我想既然大家都学到二叉树了，那么栈肯定也不陌生，我主要想加深大家对栈的理解。 试想，你在浏览网页的时候，突然发现了一个有趣的链接，你点击进去，发现原来是广告，于是你想退回到上一个网页，那么点击浏览器上方的后退图标就很轻松地退回去了。 那么，你点击一个网页，再点击一个网页，就是个进栈的过程
二叉树的四种遍历方式(递归和非递归双重实现)
记录博主学到的点滴
08-03 2300
写在前面：博主是一位普普通通的19届二本大学生，平时最大的爱好就是听听歌，逛逛B站。博主很喜欢的一句话花开堪折直须折，莫待无花空折枝：博主的理解是头一次为人，就应该做自己想做的事，做自己不后悔的事，做自己以后不会留有遗憾的事，做自己觉得有意义的事，不浪费这大好的青春年华。博主写博客目的是记录所学到的知识并方便自己复习，在记录知识的同时获得部分浏览量，得到更多人的认可，满足小小的成就感，同时在写博客的途中结交更多志同道合的朋友，让自己在技术的路上并不孤单。 目录: 1.二叉树的先序遍历  &n.
二叉树遍历_C语言_
09-30
在这个场景中，我们关注的是使用C语言实现二叉树的遍历，包括先序遍历、中序遍历和后序遍历，以及非递归的中序遍历。这些遍历方法是理解二叉树特性和操作的关键。 1. **先序遍历**：先序遍历的顺序是根节点 -> 左...
【数据结构习题】PTA 7-1 玩转二叉树 前序遍历+中序遍历
libertye的博客
05-16 1700
给定一棵二叉树的中序遍历和前序遍历，请你先将树做个镜面反转，再输出反转后的层序遍历的序列。所谓镜面反转，是指将所有非叶结点的左右孩子对换。这里假设键值都是互不相等的正整数。 输入格式： 输入第一行给出一个正整数N（≤30），是二叉树中结点的个数。第二行给出其中序遍历序列。第三行给出其前序遍历序列。数字间以空格分隔。 输出格式： 在一行中输出该树反转后的层序遍历的序列。数字间以1个空格分隔，行首尾不得有多余空格。 输入样例： 7 1 2 3 4 5 6 7 4 1 3 2 6 5 7 输出样例： 4 6 1
二叉树的非递归层次遍历
doubleintfloat的博客
09-22 1640
#include<iostream> #include<stack> #include<queue> using namespace std;typedef struct Node { char data; Node*lchild; Node*rchild; }Node;//创建一个节点 Node*BuyNode() { Node* p = new(nothrow)N
第三章（非递归层序遍历二叉树（c语言实现））
a13683857889的博客
02-07 556
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define TURE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INSEASIBLE -1 #define OVERFLOW -2 typedef char ElemType; typedef int Status; typ...
二叉树的非递归遍历及层次遍历
arui的专栏
08-14 1万+
二叉树的基本操作请看：http://blog.csdn.net/sysu_arui/article/details/7865876 前面简答介绍了二叉树的基本操作，包括二叉树的建立，销毁，递归遍历，以及其他一些常见的递归算法，现在集中讨论一下二叉树的层次遍历和非递归遍历。 二叉树的层次遍历要用到队列，前序、中序和后序非递归遍历要用到栈，这里我就不自己写队列和栈了，直接使用C++标准库中的容器适
【数据结构】C语言实现二叉树的层次遍历和非递归的深度遍历
natsong的博客
03-23 489
二叉树的层次遍历、二叉树三种深度优先遍历（先序、中序、后序）遍历的非递归实现方式。纯手写代码欢迎指正
C++使用非递归方式实现二叉树的先序、中序、后序、层次遍历
qq_43459195的博客
03-17 957
通常遍历二叉树是用的递归办法，但是当结点数过多时很容易发生溢出现象。 学习非递归的遍历过程有利于我们更好理解遍历遵循的原理，本程序使用C++的标准模板库中的栈和队列来进行辅助。 //使用C++中的引用构建二叉树，并进行非递归遍历 #include<cstdio> #include<iostream> #include<stack> #include<queue> #include<cstdlib> using namespace std; typ
二叉树的层序遍历c语言报告,C语言非递归实现二叉树的先序、中序、后序、层序遍历...
weixin_31155097的博客
05-18 646
C语言非递归实现二叉树的先序、中序、后序、层序遍历代码如下：#include #include #include #include using namespace std;//*****二叉树的二叉链表存储表示*****//typedef struct BiNode{char data;struct BiNode *lchild, *rchild;int visitCount;}BiNode, *...
详解二叉树的非递归遍历
热门推荐
编程随笔与杂谈
06-29 10万+
本文转载自：http://blog.csdn.net/zhangxiangdavaid/article/details/37115355 前言 　　对于二叉树的递归遍历比较简单，所以本文主要讨论的是非递归版。其中，中序遍历的非递归写法最简单，后序遍历最难。 节点的定义： //Binary Tree Node typedef struct node { int data; ...
C语言非递归实现二叉树的三种遍历算法：前序、中序、后续
TomOfJerry的博客
10-02 875
C语言非递归实现二叉树的三种遍历算法：前序、中序、后续目录遍历的基本概念-必读遍历示意图-必看先序遍历中序遍历后序遍历 目录 遍历的基本概念-必读 二叉树由三个元素组成，分别是根节点D，左子树L，右子树R。理论上存在六种遍历方法，分别是：DLR(先序)、LDR(中序)、LRD(后序)、DRL、RDL、RLD。实际中只有前三种遍历算法，特点是： L在R之前 根据D的前、中、后三种位置分为三种 遍历可以借助递归调用实现，方法简单便捷，本文不再介绍。 本文利用栈实现遍历，栈的特点：先进后出。利用栈主要是将树的
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

mcl19909949541

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值