c语言二叉树的层次遍历（超详细）学习笔记

最新推荐文章于 2024-10-05 18:47:59 发布
最新推荐文章于 2024-10-05 18:47:59 发布
阅读量4k 收藏 58
点赞数 34
分类专栏： 数据结构 二叉树 文章标签： 学习 笔记 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l2757721107/article/details/135073173
版权

 前言：

我学习数据结构的方式是看书加看视频，视频看的是哔哩哔哩up主的 二叉树的层次遍历 我总结并补充他所讲的内容，他的视频适合有c语言基础的看。本文章继我的上一篇文章  c语言二叉树的创建与前序、中序、后序遍历（超详细）学习笔记 ,在二叉树的前序、中序、后序的三种遍历上，继续详细解释二叉树的层次遍历。看完此片文章，一定会有所收获的！

思路：

若想实现层次遍历，那么应该是先遍历根节点A，然后遍历它的左子树B，再遍历它的右子树C，再遍历B的左子树，再遍历B的右子树...

按照这个逻辑关系，我们可以运用树+队的形式，树的结点作为队的元素。

每次入队一个树结点，进行遍历，出队，然后再在将这个树结点的左孩子和右孩子进行入队,依次进行...最终得到层次遍历：A B C D E F G

一、创建树结构体

//创建树结构体
typedef struct TreeNode
{
    char data;
    struct TreeNode* lChild;
    struct TreeNode* rChild;
}treeNode;

二、创建循环队列结构体（链式存储方式）

循环队列的解释：

队的特点是先进先出，循环队列适应两种存储结构，顺序存储有队满情况，链式存储不存在队满情况。因为是链式存储方式，所以不能通过顺序存储中的real和front来判断队空，通过链式结构中的指针域来联系队中的元素彼此。

那么就有两种循环方式：单循环队列和双循环队列方式。所以我会展示两种方式。当然两种方法各有所爱了，总体上是差不多的。

（1）创建单循环队列

//创建循环队列结构体
typedef struct QueueNode
{
    treeNode* data;树的结点作为元素
    struct QueueNode* next;
}QueueNode;

（2）创建双循环队列

//创建双循环队列结构体
typedef struct QueueNode
{
    treeNode* data; //树的结点作为元素
    struct QueueNode* next;
    struct QueueNode* pre;
}QueueNode;

三、初始化二叉树

仍是使用先序方式进行传入数据 并运用递归。如果想了解递归详细的推导，可以看看我的这篇文章 c语言二叉树的创建与前序、中序、后序遍历（超详细）学习笔记

//初始化二叉树
TreeNode* creatTree()
{
    TreeNode* T;
    char ch;
    scanf_s("%c", &ch);//通过输入的ch是否是‘#’来判断该节点是否有孩子节点

    if (ch == '#') //'#'代表传入的是空结点
    {
        //此时为空结点
        return NULL;
    }
    else
    {
        //不为空
        T = (TreeNode*)malloc(sizeof(TreeNode));
        T->data = ch;
        //创建左子树，逻辑一致，进行递归
        T->lChild = creatTree();
        //创建右子树，逻辑一致，进行递归
        T->rChild = creatTree();
        return T;

    }
}

四、创建空队

（1）单循环队列：

//创建空队
QueueNode* initQueue()
{
    QueueNode* Q = (QueueNode*)malloc(sizeof(QueueNode));
    Q->data = NULL;
    Q->next = Q;
    return Q;
}

（2）双循环队列：

//创建空队
QueueNode* initQueue()
{
    QueueNode* Q = (QueueNode*)malloc(sizeof(QueueNode));
    Q->data = NULL;
    Q->next = Q;
    Q->pre = Q;
    return Q;
}

五、入队  （尾插法入队）

尾插法入队的解释：先进先出，方便出队时快速找到当前元素，Q->next == 出队的元素 

如：按照1，2，3，4，5的顺序入队，那么出队的顺序为1，2，3，4，5

头插法入队：Q->1->2->3->4->5，若想出队1，需找到元素1 即：Q->nest == 1，非常快速。

（1）单循环队列：

//入队  尾插法
void enQueue(QueueNode* Q, treeNode* data)
{
    QueueNode* node = (QueueNode*)malloc(sizeof(QueueNode));
    QueueNode* q = Q->next;
    while(q->next != Q)
    { 
        q = q->next;
    }
    node->data = data;
    q->next = node;
    node->next = Q;    
}

（2）双循环队列：

//入队  尾插法
void enQueue(QueueNode* Q, treeNode* data)
{
    QueueNode* node = (QueueNode*)malloc(sizeof(QueueNode));
    node->data = data;
    node->pre = Q->pre;
    node->next = Q;
    Q->pre->next = node;
    Q->pre = node;
}

六、判断队是否为空

//判断队是否为空
int isEmpty(QueueNode* Q)
{
    if (Q->next == Q)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

七、出队  （头插法出队）

头插法出队，非常快速的找到需要出队的元素，Q->next == 出队的元素

找到出队元素，进行出队操作并返回其元素。

（1）单循环队列：

//出队  头插法
treeNode* deQueue(QueueNode* Q)
{
    if (isEmpty(Q))
    {
        return NULL;
    }
    else
    {
        QueueNode* node = Q->next;
        treeNode* T = node->data;
        Q->next = node->next;
        free(node);
        return T;
    }
}

（2）双循环队列：

//出队  头插法
treeNode* deQueue(QueueNode* Q)
{
    if (isEmpty(Q))
    {
        return NULL;
    }
    else
    {
        QueueNode* node = Q->next;
        treeNode* T = node->data;
        Q->next = node->next;
        node->next->pre = Q;
        free(node);
        return T;
    }
}

八、层次遍历

//层次遍历
void levelTraverse(QueueNode* Q, treeNode* T)
{
    //先进队
    enQueue(Q, T);
    while (!isEmpty(Q))
    {
        treeNode* node = deQueue(Q);
        //将node 进行遍历
        printf("%c ", node->data);
        //如果有左孩子
        if (node->lChild)
        {
            enQueue(Q, node->lChild);
        }
        //如果有右孩子
        if (node->rChild)
        {
            enQueue(Q, node->rChild);
        }
    }
}

思路：每次入队一个树结点，出队并取出其元素，进行遍历，然后再在将这个树结点的左孩子和右孩子进行入队,依次进行...最终得到层次遍历：A B C D E F G

九、前序遍历

//前序遍历   根 左 右
void preOrder(treeNode* T)
{
    if (T == NULL)
    {
        return;
    }
    else
    {       //先办事
        printf("%c ", T->data);
        //左孩子                                    
        preOrder(T->lChild);
        //右孩子                                    
        preOrder(T->rChild);
    }
}

十、完整代码

(1)单循环队列完整代码：

#include<stdio.h>
#include<stdlib.h>
//创建树结构体
typedef struct TreeNode
{
    char data;
    struct TreeNode* lChild;
    struct TreeNode* rChild;
}treeNode;
//创建循环队列结构体
typedef struct QueueNode
{
    treeNode* data;树的结点作为元素
    struct QueueNode* next;
}QueueNode;
//初始化二叉树
TreeNode* creatTree()
{
    TreeNode* T;
    char ch;
    scanf_s("%c", &ch);//通过输入的ch是否是‘#’来判断该节点是否有孩子节点

    if (ch == '#') //'#'代表传入的是空结点
    {
        //此时为空结点
        return NULL;
    }
    else
    {
        //不为空
        T = (TreeNode*)malloc(sizeof(TreeNode));
        T->data = ch;
        //创建左子树，逻辑一致，进行递归
        T->lChild = creatTree();
        //创建右子树，逻辑一致，进行递归
        T->rChild = creatTree();
        return T;

    }
}
//创建空队
QueueNode* initQueue()
{
    QueueNode* Q = (QueueNode*)malloc(sizeof(QueueNode));
    Q->data = NULL;
    Q->next = Q;
    return Q;
}
//入队  尾插法
void enQueue(QueueNode* Q, treeNode* data)
{
    QueueNode* node = (QueueNode*)malloc(sizeof(QueueNode));
    QueueNode* q = Q->next;
    while(q->next != Q)
    { 
        q = q->next;
    }
    node->data = data;
    q->next = node;
    node->next = Q;    
}
//判断队是否为空
int isEmpty(QueueNode* Q)
{
    if (Q->next == Q)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
//出队  头插法
treeNode* deQueue(QueueNode* Q)
{
    if (isEmpty(Q))
    {
        return NULL;
    }
    else
    {
        QueueNode* node = Q->next;
        treeNode* T = node->data;
        Q->next = node->next;
        free(node);
        return T;
    }
}
//层次遍历
void levelTraverse(QueueNode* Q, treeNode* T)
{
    //先进队
    enQueue(Q, T);
    while (!isEmpty(Q))
    {
        treeNode* node = deQueue(Q);
        //将node 进行打印
        printf("%c ", node->data);
        //如果有左孩子
        if (node->lChild)
        {
            enQueue(Q, node->lChild);
        }
        //如果有右孩子
        if (node->rChild)
        {
            enQueue(Q, node->rChild);
        }
    }
}
//前序遍历   根 左 右
void preOrder(treeNode* T)
{
    if (T == NULL)
    {
        return;
    }
    else
    {       //先办事
        printf("%c ", T->data);
        //左孩子                                    
        preOrder(T->lChild);
        //右孩子                                    
        preOrder(T->rChild);
    }
}
int main()
{
    QueueNode* Q = initQueue();
    treeNode* T = creatTree();
    printf("前序遍历：\n");
    preOrder(T);
    printf("\n");
    printf("层次遍历：\n");
    levelTraverse(Q, T);
    printf("\n");
    return 0;
}

(2)双循环队列完整代码：

#include<stdio.h>
#include<stdlib.h>
//创建树结构体
typedef struct TreeNode
{
    char data;
    struct TreeNode* lChild;
    struct TreeNode* rChild;
}treeNode;
//创建双循环队列结构体
typedef struct QueueNode
{
    treeNode* data; //树的结点作为元素
    struct QueueNode* next;
    struct QueueNode* pre;
}QueueNode;
//初始化二叉树
TreeNode* creatTree()
{
    TreeNode* T;
    char ch;
    scanf_s("%c", &ch);//通过输入的ch是否是‘#’来判断该节点是否有孩子节点

    if (ch == '#') //'#'代表传入的是空结点
    {
        //此时为空结点
        return NULL;
    }
    else
    {
        //不为空
        T = (TreeNode*)malloc(sizeof(TreeNode));
        T->data = ch;
        //创建左子树，逻辑一致，进行递归
        T->lChild = creatTree();
        //创建右子树，逻辑一致，进行递归
        T->rChild = creatTree();
        return T;

    }
}
//创建空队
QueueNode* initQueue()
{
    QueueNode* Q = (QueueNode*)malloc(sizeof(QueueNode));
    Q->data = NULL;
    Q->next = Q;
    Q->pre = Q;
    return Q;
}
//入队  尾插法
void enQueue(QueueNode* Q, treeNode* data)
{
    QueueNode* node = (QueueNode*)malloc(sizeof(QueueNode));
    node->data = data;
    node->pre = Q->pre;
    node->next = Q;
    Q->pre->next = node;
    Q->pre = node;
}
//判断队是否为空
int isEmpty(QueueNode* Q)
{
    if (Q->next == Q)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
//出队  头插法
treeNode* deQueue(QueueNode* Q)
{
    if (isEmpty(Q))
    {
        return NULL;
    }
    else
    {
        QueueNode* node = Q->next;
        treeNode* T = node->data;
        Q->next = node->next;
        node->next->pre = Q;
        free(node);
        return T;
    }
}
//层次遍历
void levelTraverse(QueueNode* Q, treeNode* T)
{
    //先进队
    enQueue(Q, T);
    while (!isEmpty(Q))
    {
        treeNode* node = deQueue(Q);
        //将node 进行遍历
        printf("%c ", node->data);
        //如果有左孩子
        if (node->lChild)
        {
            enQueue(Q, node->lChild);
        }
        //如果有右孩子
        if (node->rChild)
        {
            enQueue(Q, node->rChild);
        }
    }
}
//前序遍历   根 左 右
void preOrder(treeNode* T)
{
    if (T == NULL)
    {
        return;
    }
    else
    {       //先办事
        printf("%c ", T->data);
        //左孩子                                    
        preOrder(T->lChild);
        //右孩子                                    
        preOrder(T->rChild);
    }
}
int main()
{
    int index = 0;
    QueueNode* Q = initQueue();
    treeNode* T = creatTree();
    printf("前序遍历：");
    preOrder(T);
    printf("\n");
    printf("层次遍历：");
    levelTraverse(Q, T);
    printf("\n");
    return 0;
}

十一、运行结果

输入：ABD##E##CF##G##

​

总结：

二叉树层次遍历的好处包括：

1.按照层级顺序访问节点：层次遍历可以按照树的层级顺序访问节点，从根节点开始，逐层向下遍历，这样可以更加直观地观察和理解整个二叉树的结构。

2.方便实现广度优先搜索：层次遍历是广度优先搜索（BFS）的一种实现方式。BFS是一种重要的图搜索算法，广泛应用于图的遍历、路径搜索、连通性判断等问题中。层次遍历的结果正好可以按照广度优先搜索的顺序得到。

3.快速查找某一层的节点：对于二叉树层次遍历的结果，每一层的节点都是按照从左到右的顺序排列的。因此，可以直接通过索引或下标的方式快速查找到某一层的节点。这种特性在某些问题中非常有用，比如在二叉树的每一层中查找特定的节点或值。

4.方便处理与层次相关的问题：有些问题与二叉树的层次相关，比如计算二叉树的最大深度、最小深度，判断二叉树是否是完全二叉树等等。通过层次遍历，可以轻松地处理与层次相关的问题，因为遍历的结果已经按照层级顺序排列好了。

总之，二叉树层次遍历可以提供对二叉树结构的直观理解，方便实现广度优先搜索，快速查找某一层的节点，并处理与层次相关的问题。

实现二叉树的层次遍历需要树+队的结合，队是循环队列，那么有单循环队列和双循环队列两种方式进行实现。制作不易，真心想让你懂，还是有不足的地方，望见谅嘞。

小苏先生.
关注
专栏目录
二叉树的层次遍历（c语言）
05-31
这是用c语言编写的二叉树层次遍历程序，使用非递归的方法实现。欢迎使用。
C语言实现二叉树的层次遍历
weixin_45337637的博客
07-27 1万+
1. 基本思路 进行层次遍历时构建一个辅助队列，先将二叉树根节点入队，然后出队，访问出队结点，若它有左子树，将左子树根节点入队，然后出队，访问出队结点…，右子树也同样如此，循环往复直到队列为空。 2.代码 #include<stdio.h> #include <malloc.h> //二叉树的链式存储结构 typedef struct BiTNode { char data; struct BiTNode* lchild, * rchild; }BiTNode, * BiTre.
二叉树的【层序遍历】【垂序遍历】具体思路，文中包含多种方法（附完整代码）
最新发布
bufangbufang的博客
10-05 882
本文将主要围绕以下问题进行讨论：二叉树的层序遍历、垂序遍历。层序遍历的两种方法 【迭代法】【递归法】垂序遍历的两种方法 【递归排序】【哈希递归】对于垂序遍历的方法多种多样，大家也可以多多尝试不同的思路。
【C语言】二叉树的层序遍历
wzx0806的博客
07-30 3567
要对二叉树进行层序遍历，那么我们首先得先创建出来一个二叉树了。
二叉树的层次遍历详解（C语言版）
qq_52607834的博客
05-15 1万+
非递归版的层次遍历，简单易懂！！！
数据结构之树的层次遍历（附带查找）、深度求值
摩尔的博客
06-30 2668
二叉树的层次遍历，顾名思义就是指从二叉树的第一层（根节点）开始，从上至下逐层遍历，在同一层中，则按照从左到右的顺序对节点逐个访问。 算法思想：用一个队列保存被访问的当前节点的左右孩子以实现层序遍历。 在进行层次遍历的时候，设置一个队列结构，遍历从二叉树的根节点开始，首先将根节点指针入队列，然后从队头取出一个元素，每取一个元素，执行下面两个操作： 1、访问该元素所指向的节点 2、若该元素
算法通关村——树的层次遍历
moqi997752的博客
11-02 4227
本文介绍了树的层次遍历方法，已经基于树的层次遍历拓展的几个遍历问题
层次遍历_树
han_yiyang的博客
03-30 7853
哈喽大家好，这里是蒟蒻hanyiyang的博文，今天，我来给大家，介绍一个关于图的算法，希望能帮助到大家！！！ 层次遍历 大家来看一看上面这个图，为什么要说这是层次遍历呢，因为，这种遍历方式是一层一层进行的： 第一层：F 第二层：CE 第三层：ADHG 第四层：BM 这个就是层次遍历的大致顺序 那么算法是怎样的呢？？？ 先将根节点入队 只要队列不为空，只要队首元素有左儿子且左儿子没有被访问过...
二叉树的先序、中序、后序以及层次遍历
热门推荐
qq_50931436的博客
11-18 8万+
要进行层次遍历，需要建立一个循环队列。先将二叉树头结点入队列，再将头结点的左、右节点入队列，此时头节点就可以出队列遍历，然后重复上面的操作直到队头和队尾为空，这就是层次遍历。例如：一棵二叉树的中序是：BDCAEHGKF 后序是：DCBHKGFEA。当经过一次，被写出来的点，我们称它为先序遍历。当经过两次，被写出来的点，我们称它为中序遍历。当经过三次，被写出来的点，我们称它为后序遍历。
二叉树的层次遍历（C语言）
chenshengnanii的博客
05-24 2万+
一、二叉树的概念以及结构 二叉树是n(n>=0)个节点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根节点和两棵互不相交的、分别称为根节点的左子树和右子树组。 二、二叉树的遍历图解 先序遍历 中序遍历 后序遍历 层次遍历 ...
树的层次遍历
听得到微笑的博客
02-15 4万+
二叉树的前序、中序、后序遍历我想大家应该都很熟悉了，那我们今天就来讲一下二叉树的层次遍历。 二叉树的前序、中序、后序遍历需要用到栈（递归的过程也就是一个栈），层次遍历需要借助队列这个数据结构。 层次遍历的思路 我们给出一个二叉树： 这棵二叉树的层次遍历次序为：A、B、C、D、F、G 以人的思维来看层次遍历貌似比前、中、后序遍历更加简单易懂，但是程序到底如何实现这样的效果呢...
【C语言二叉树遍历实例】C语言二叉树遍历实例
05-20
二叉树的遍历C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历...
erchashu.rar_C语言 二叉树 遍历 C语言_二叉树遍历
09-22
本文将深入探讨C语言中实现二叉树遍历的方法，包括先根遍历、中根遍历和后根遍历，并通过程序分析帮助理解这些概念。 **先根遍历（Preorder Traversal）** 先根遍历的顺序是：先访问根节点，然后递归地遍历左子树，...
C语言二叉树建立遍历冒泡排序快速排序等.rar
06-03
本压缩包文件“C语言二叉树建立遍历冒泡排序快速排序等.rar”提供了这些语言的相关案例，帮助学习者深入理解数据结构和算法。以下是针对这些主题的详细解释： 1. **C语言**：C语言是一种强大的系统级编程语言，被...
C语言实现二叉树遍历的迭代算法
09-04
以上就是C语言实现二叉树遍历的迭代算法，通过这种方式，我们可以高效地遍历二叉树，而无需像递归那样增加调用栈的压力。这对于处理大规模数据或者深度很大的二叉树特别有用。在实际编程中，理解并掌握这些算法对...
【数据结构】2——二叉树遍历
qq_43507078的博客
09-08 1118
二叉树遍历
树的应用 —— 二叉树的遍历【层次遍历、遍历序列还原树】
谢谢你们的关注
09-24 3245
树的应用 —— 二叉树的遍历【层次遍历、遍历序列还原树】
（数据结构）二叉树层次遍历
weixin_51927215的博客
03-30 1万+
二叉树层次遍历 二叉树层次遍历的实现思想是：通过队列数据结构，从树的根结点开始，依次将其左孩子和右孩子入队；而后每次队列中一个结点出队，都将其左孩子和右孩子入队，直到树中所有结点都出队，出队结点的先后顺序就是层次遍历的最终结果 图1 二叉树 以上图 1 为例，层次遍历的过程如下： 首先，根结点 1 入队 根结点 1 出队，出队的同时，将左孩子 2 和右孩子 3 分别入队 队头结点 2 出队，出队的同时，将结点 2 的左孩子 4 和右孩子 5 依次入队 队头结点 3 ...
C语言二叉树层次遍历
09-25
C语言二叉树的层次遍历是一种广度优先搜索算法，它按照从上到下、从左到右的顺序遍历二叉树的每个节点。具体操作如下： 1. 创建一个队列，并将根节点入队。 2. 当队列不为空时，执行以下步骤： - 出队一个节点，并访问该节点。 - 如果该节点有左子节点，则将左子节点入队。 - 如果该节点有右子节点，则将右子节点入队。 3. 重复步骤2，直到队列为空。 这样，就可以按层次遍历的顺序访问二叉树的所有节点。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小苏先生.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值