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

最新推荐文章于 2024-02-21 22:58:25 发布
最新推荐文章于 2024-02-21 22:58:25 发布
阅读量1.8k 收藏 24
点赞数 25
分类专栏： 数据结构 二叉树 文章标签： 学习 笔记 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.方便处理与层次相关的问题：有些问题与二叉树的层次相关，比如计算二叉树的最大深度、最小深度，判断二叉树是否是完全二叉树等等。通过层次遍历，可以轻松地处理与层次相关的问题，因为遍历的结果已经按照层级顺序排列好了。

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

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

小苏先生.
关注
  • 25
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉树的遍历及其应用C/C++代码实现
Ycy的博客
06-08 8054
二叉树的存储结构： 顺序存储：只适合完全二叉树。 链式存储：利用这种结点结构所得二叉树的存储结构分别称之为二叉链表和三叉链表。 二叉树的遍历： 规定先左后右，按照根结点的访问次序可分为先（根） 序遍历、中（根） 序遍历和后（根） 序遍历。 先序遍历序列：ABCDEGF 中序遍历序列：CBEGDFA 后序遍历序列：CGEFDBA 注意： 另外由二叉树的先序序列和中序序列，或由其后序序列和中序序列均能唯一地确定一棵二叉树。 但先序序列和后序序列不能唯一确定一棵二叉树。 遍历的应用： 1，建立二叉链表 2，复
层次遍历_树
han_yiyang的博客
03-30 7534
哈喽大家好，这里是蒟蒻hanyiyang的博文，今天，我来给大家，介绍一个关于图的算法，希望能帮助到大家！！！ 层次遍历 大家来看一看上面这个图，为什么要说这是层次遍历呢，因为，这种遍历方式是一层一层进行的： 第一层：F 第二层：CE 第三层：ADHG 第四层：BM 这个就是层次遍历的大致顺序 那么算法是怎样的呢？？？ 先将根节点入队 只要队列不为空，只要队首元素有左儿子且左儿子没有被访问过...
C语言实现二叉树遍历的迭代算法
09-04
主要介绍了C语言实现二叉树遍历的迭代算法,包括二叉树的中序遍历、先序遍历及后序遍历等,是非常经典的算法,需要的朋友可以参考下
树的遍历（四种全）｜C++
taoxing
02-15 2万+
一.树的遍历 树的遍历也叫树的搜索，是指按照某种规则对树的节点进行一遍不重复的访问。按照不同的方式可以分为树的前序遍历、中序遍历、后序遍历和层序遍历。 二.前序遍历 1）树的前序遍历指的是对树按照根、左、右的规律进行访问。 遍历结果为：F, B, A, D, C, E, G, I, H 2）递归代码实现（对于前序、中序、后序遍历的递归实现非常的相似，只是改变输出数组语句的位置） //存储遍历结果的数组 vector<int> v; //前序遍历函数 vector<int
树的遍历代码
qq_52538610的博客
02-21 212
【代码】树的遍历代码。
【树的四种遍历方法（遍历排序二叉树）】
weixin_43915790的博客
06-23 1676
文章目录 一、建立一个排序二叉树 二、四种遍历 前言 这里先给出建立一颗普通的排序二叉树，平衡二叉树的建立以及操作，等复习到再写吧。 一、排序二叉树 排序二叉树，即当前节点左子树 < 当前节点 < 当前节点的右子树 的特殊的二叉树，便于查找。 排序二叉树的构造很简单，使用三个树节点指针。currentNode(指向当前遍历节点地址的指针) parentNode(保存当前遍历节点的父节点地址的指针) ，和一个新节点指针newNode 每插入一个新节点，移动这三个指...
算法通关村——树的层次遍历
moqi997752的博客
11-02 2512
本文介绍了树的层次遍历方法，已经基于树的层次遍历拓展的几个遍历问题
二叉树的先序、中序、后序以及层次遍历
热门推荐
qq_50931436的博客
11-18 8万+
要进行层次遍历，需要建立一个循环队列。先将二叉树头结点入队列，再将头结点的左、右节点入队列，此时头节点就可以出队列遍历，然后重复上面的操作直到队头和队尾为空，这就是层次遍历。例如：一棵二叉树的中序是：BDCAEHGKF 后序是：DCBHKGFEA。当经过一次，被写出来的点，我们称它为先序遍历。当经过两次，被写出来的点，我们称它为中序遍历。当经过三次，被写出来的点，我们称它为后序遍历。
树的层次遍历
听得到微笑的博客
02-15 4万+
二叉树的前序、中序、后序遍历我想大家应该都很熟悉了，那我们今天就来讲一下二叉树的层次遍历。 二叉树的前序、中序、后序遍历需要用到栈（递归的过程也就是一个栈），层次遍历需要借助队列这个数据结构。 层次遍历的思路 我们给出一个二叉树： 这棵二叉树的层次遍历次序为：A、B、C、D、F、G 以人的思维来看层次遍历貌似比前、中、后序遍历更加简单易懂，但是程序到底如何实现这样的效果呢...
二叉树的层次遍历（C语言）
chenshengnanii的博客
05-24 2万+
一、二叉树的概念以及结构 二叉树是n(n>=0)个节点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根节点和两棵互不相交的、分别称为根节点的左子树和右子树组。 二、二叉树的遍历图解 先序遍历 中序遍历 后序遍历 层次遍历 ...
【C语言二叉树遍历实例】C语言二叉树遍历实例
最新发布
05-20
二叉树的遍历C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历...
erchashu.rar_C语言 二叉树 遍历 C语言_二叉树遍历
09-22
二叉树遍历，先根，中根，后根，及程序分析。c语言实现
C语言二叉树的三种遍历方式的实现及原理
12-31
二叉树遍历分为三种：前序、中序、后序，其中序遍历最为重要。为啥叫这个名字？是根据根节点的顺序命名的。 比如上图正常的一个满节点，A：根节点、B：左节点、C：右节点，前序顺序是ABC（根节点排最先，然后同级先...
二叉树层次遍历.rar
04-15
数据结构课程设计实例二叉树层次遍历 数据结构课程设计实例二叉树层次遍历 数据结构课程设计实例二叉树层次遍历 数据结构课程设计实例二叉树层次遍历 数据结构课程设计实例二叉树层次遍历 数据结构课程设计实例...
树的应用 —— 二叉树的遍历【层次遍历、遍历序列还原树】
谢谢你们的关注
09-24 2888
树的应用 —— 二叉树的遍历【层次遍历、遍历序列还原树】
二叉树遍历之层次遍历算法入门详解
sunnyoldboy博客
07-22 5816
层次遍历的原理很简单，总结为一句话就是“从上到下，从左到右”，就是从树根开始逐层访问二叉树的结点，每一层按照从左到右的次序进行访问。 为了方便实现层次遍历，可以引入队列来缓存二叉树上的所有结点，出队列则访问。 入队列的规则：树根先入，之后立刻出队列并访问，然后树根的左、右子树树根依次入队列，之后依次出队列。没出来一个结点，都将其左、右子树树根依次入队（为空者不入）。.........
【C语言】二叉树的层序遍历
wzx0806的博客
07-30 2831
要对二叉树进行层序遍历，那么我们首先得先创建出来一个二叉树了。
简单讲解前序遍历，中序遍历，后序遍历和层次遍历
JIE1575100的博客
10-31 2169
leetcode数据结构-二叉树
树的几种遍历方式的代码（个人学习版）
demo_omeb的博客
03-24 112
【代码】树的几种遍历方式的代码（个人学习版）
C语言二叉树层次遍历
09-25
C语言二叉树的层次遍历是一种广度优先搜索算法，它按照从上到下、从左到右的顺序遍历二叉树的每个节点。具体操作如下： 1. 创建一个队列，并将根节点入队。 2. 当队列不为空时，执行以下步骤： - 出队一个节点，并访问该节点。 - 如果该节点有左子节点，则将左子节点入队。 - 如果该节点有右子节点，则将右子节点入队。 3. 重复步骤2，直到队列为空。 这样，就可以按层次遍历的顺序访问二叉树的所有节点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小苏先生.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值