二叉树层次遍历算法——C/C++

最新推荐文章于 2024-06-18 13:52:22 发布
最新推荐文章于 2024-06-18 13:52:22 发布
阅读量8.9w 收藏 1.3k
点赞数 363
分类专栏： 数据结构 文章标签： C/C++ 二叉树层次遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42109012/article/details/92250160
版权

二叉树层次遍历

层次遍历基础需要了解二叉树、队列。
二叉树基本运算：https://blog.csdn.net/weixin_42109012/article/details/92000919
顺序队基本运算：https://blog.csdn.net/weixin_42109012/article/details/92104948

1. 算法思想

用一个队列保存被访问的当前节点的左右孩子以实现层次遍历。
在进行层次遍历的时候，设置一个队列结构，遍历从二叉树的根节点开始，首先将根节点指针入队列，然后从队头取出一个元素，每取一个元素，执行下面两个操作：

  1. 访问该元素所指向的节点
  2. 若该元素所指节点的左右孩子节点非空，则将该元素所指节点的左孩子指针和右孩子指针顺序入队。此过程不断进行，当队列为空时，二叉树的层次遍历结束。

2. 原理解释

2.1. 二叉树图

一个二叉树，层次遍历就是每一行每一行的取出数据。
这个图的结果就是 ABCDEFGH
在这里插入图片描述

2.2. 层次遍历过程图

就是先父节点进入队列，然后循环，出队时带入下一组子节点进队，没有就没有进入队列的，当队列为空时结束循环。
在这里插入图片描述

3. 代码实现

3.1 实现步骤

1、首先将二叉树的根节点进入队列中，判断队列不为NULL。
2、打印输出该节点存储的元素。
3、判断节点如果有孩子（左孩子、右孩子），就将孩子进入队列中。
4、循环以上操作，直到 BT->lchild == NULL、BT->rchild=NULL。

3.2 全部代码

#define _CRT_SECURE_NO_WARNINGS // VS忽略警告，其它应该不需要

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

#define MAX_SIZE 128
#define STR_SIZE 1024

typedef struct Node {    // 定义二叉链
    char         data;   // 数据元素
    struct Node* lchild; // 指向左孩子节点
    struct Node* rchild; // 指向右孩子节点
} BTNode;                // struct Node 的别名

typedef struct Quene {      // 定义顺序队
    int     front;          // 队头指针
    int     rear;           // 队尾指针
    BTNode* data[MAX_SIZE]; // 存放队中元素
} SqQueue;                  // struct Queue 的别名

/**
 * 队列函数
 */
void initQueue(SqQueue** q);             // 初始化队列
bool emptyQueue(SqQueue* q);             // 判断队列空
bool enQueue(SqQueue* q, BTNode* node);  // 入队
bool deQueue(SqQueue* q, BTNode** node); // 出队

/**
 * 二叉树函数
 */
// void createBTNode2(BTNode** BT);                  // 创建二叉树
int  createBTNode(BTNode** BT, char* str, int n); // 创建二叉树
void preOrder(BTNode* BT);                        // 前序遍历
void inOrder(BTNode* BT);                         // 中序遍历
void postOrder(BTNode* BT);                       // 后序遍历
void levelOrder(BTNode* BT);                      // 层次遍历

/**
 * 画树函数
 */
void draw_level(BTNode* node, bool left, char* str); // 画分支
void draw(BTNode* root);                             // 画根节点

/***************************************************************************
 * @date    2019/12/08
 * @brief   层次遍历二叉树
 * @param   BT  二叉树根节点
 ***************************************************************************/
void levelOrder(BTNode* BT) {
    SqQueue* q;       // 定义队列
    initQueue(&q);    // 初始化队列
    if (BT != NULL) { // 根节点指针进队列
        enQueue(q, BT);
    }
    // 一层一层的把节点存入队列，当没有孩子节点时就不再循环
    while (!emptyQueue(q)) {      // 队不为空循环
        deQueue(q, &BT);          // 出队时的节点
        printf("%c", BT->data);   // 输出节点存储的值
        if (BT->lchild != NULL) { // 有左孩子时将该节点进队列
            enQueue(q, BT->lchild);
        }
        if (BT->rchild != NULL) { // 有右孩子时将该节点进队列
            enQueue(q, BT->rchild);
        }
    }
}

int main() {
    // 例子：ABDH###E##CF##G##
    BTNode* BT;
    printf("请输入字符串：");
    char* str = (char*)malloc(sizeof(char) * STR_SIZE);
    scanf("%s", str);
    if (strlen(str) == createBTNode(&BT, str, 0)) {
        printf("二叉树建立成功\n");
    }
    // printf("请输入字符串：");
    // createBTNode2(&BT);
    // draw(BT);

    printf("\n先序遍历结果：");
    preOrder(BT);

    printf("\n中序遍历结果：");
    inOrder(BT);

    printf("\n后序遍历结果：");
    postOrder(BT);

    printf("\n层序遍历结果：");
    levelOrder(BT);

    return 0;
}

// 初始化队列
void initQueue(SqQueue** q) {
    if (!((*q) = (SqQueue*)malloc(sizeof(SqQueue)))) {
        printf("内存分配失败！");
        exit(-1);
    }
    (*q)->front = (*q)->rear = -1; // 置 -1
}

// 判断队列是否为空
bool emptyQueue(SqQueue* q) {
    // 首指针和尾指针相等，说明为空。空-返回真，不空-返回假
    if (q->front == q->rear) {
        return true;
    }
    return false;
}

// 进队列
bool enQueue(SqQueue* q, BTNode* node) {
    // 判断队列是否满了。满（插入失败）-返回假，不满（插入成功）-返回真
    if (q->rear == MAX_SIZE - 1) {
        return false;
    }
    q->rear++;               // 头指针加 1
    q->data[q->rear] = node; // 传值
    return true;
}

// 出队列
bool deQueue(SqQueue* q, BTNode** node) {
    // 判断是否空了。空（取出失败）-返回假，不空（取出成功）-返回真
    if (q->front == q->rear) {
        return false;
    }
    q->front++;                // 尾指针加 1
    *node = q->data[q->front]; // 取值
    return true;
}

// 创建二叉树
int createBTNode(BTNode** BT, char* str, int n) {
    char ch = str[n++];  // 把第 n 个字符赋给ch,方便后面判断，字符下标后移
    if (ch != '\0') {    // 如果 ch 不等于结束符就继续创建，否则就结束
        if (ch == '#') { // 以 # 号代表 NULL，下面没有了
            *BT = NULL;
        } else {
            if (!(*BT = (BTNode*)malloc(sizeof(BTNode)))) {
                printf("内存分配失败！");
                exit(-1);
            } else {
                (*BT)->data = ch;
                n           = createBTNode(&((*BT)->lchild), str, n); // 左递归创建
                n           = createBTNode(&((*BT)->rchild), str, n); // 右递归创建
            }
        }
    }
    // 返回 n，记录字符串使用到哪里了
    return n;
}
// 创建二叉树
// void createBTNode2(BTNode** BT) {
//     char ch;
//     ch = getchar();
//     if (ch == '#') {
//         *BT = NULL;
//     } else {
//         if (!(*BT = (BTNode*)malloc(sizeof(BTNode)))) {
//             printf("内存分配失败！");
//             return;
//         } else {
//             (*BT)->data = ch;
//             createBTNode2(&((*BT)->lchild)); // 分配成功则接着建立左子树和右子树
//             createBTNode2(&((*BT)->rchild));
//         }
//     }
// }

// 先序遍历
void preOrder(BTNode* BT) {
    if (BT != NULL) {           // 判断不为空
        printf("%c", BT->data); // 访问根节点
        preOrder(BT->lchild);   // 递归，先序遍历左子树
        preOrder(BT->rchild);   // 递归，先序遍历右子树
    }
}

// 中序遍历
void inOrder(BTNode* BT) {
    if (BT != NULL) {
        inOrder(BT->lchild);
        printf("%c", BT->data);
        inOrder(BT->rchild);
    }
}

// 后序遍历
void postOrder(BTNode* BT) {
    if (BT != NULL) {
        postOrder(BT->lchild);
        postOrder(BT->rchild);
        printf("%c", BT->data);
    }
}

/*****************************************************************************
* @date   2020/4/19
* @brief  水平画树
* @param  node	二叉树节点
* @param  left	判断左右
* @param  str 	可变字符串
*****************************************************************************/
void draw_level(BTNode* node, bool left, char* str) {
    if (node->rchild) {
        draw_level(node->rchild, false, strcat(str, (left ? "|     " : "      ")));
    }

    printf("%s", str);
    printf("%c", (left ? '\\' : '/'));
    printf("-----");
    printf("%c\n", node->data);

    if (node->lchild) {
        draw_level(node->lchild, true, strcat(str, (left ? "      " : "|     ")));
    }
    //  "      " : "|     " 长度为 6
    str[strlen(str) - 6] = '\0';
}

/*****************************************************************************
* @date   2020/4/19
* @brief  根节点画树
* @param  root	二叉树根节点
*****************************************************************************/
void draw(BTNode* root) {
    char str[STR_SIZE];
    memset(str, '\0', STR_SIZE);

    /**
     * 1. 在 windows 下，下面是可执行的
     * 2. 在 Linux   下，执行会报 Segmentation fault
     *      需要使用中间变量
     */
    if (root->rchild) {
        draw_level(root->rchild, false, str);
    }
    printf("%c\n", root->data);
    if (root->lchild) {
        draw_level(root->lchild, true, str);
    }
}

4. 结果展示

创建二叉树是以 “#” 为结束符NULL。
例子就是最上面的图：ABDH###E##CF##G##
结果应该为：ABCDEFGH
在这里插入图片描述

有人_295
关注
  • 363
    点赞
  • 踩
  • 1387
    收藏
    觉得还不错? 一键收藏
  • 31
    评论
专栏目录
二叉树层序遍历-C++
qq_42181301的博客
08-12 419
1.自上而下层序遍历输出，题目描述参见力扣102 #include <iostream> #include <vector> #include <queue> using namespace std; struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(): val(0),left(nullptr), right(nullptr) {} TreeNode(int data
C++实现二叉树层序遍历
weixin_44915226的博客
08-19 2920
层序遍历图示 实现二叉树的层次遍历，要利用到队列。 基本思想： 1.先将根节点放到队列中 2.根节点弹出队列，然后将根节点的左、右儿子入队 3.弹出左儿子，放入左儿子的左右儿子 4.弹出右儿子，放入右儿子的左右儿子 5.重复3、4步 图示过程： 所用的二叉树如下 队列的操作： 将根节点弹出，放入左右儿子： 将B节点弹出，放入左右儿子(只有右儿子)： 把D节点弹出，放入左右儿子： C、E、F都没有儿子节点，所以直接弹出队列即可：   C++代码实现 1.利用前序遍历思想输入二叉树。(前序
数据结构——二叉树的操作 (层序遍历)（C++实现）
qq_67693066的博客
04-26 788
数据结构——二叉树的操作（层序遍历）（C++实现）
二叉树的层次遍历
L的博客
01-28 1505
本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了。需要注意的是，只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点.关键点在于queue.size()在上一题基础上反转结果即可。
【C++数据结构】二叉树的层序遍历
最新发布
2301_80937868的博客
06-18 706
在线性结构中，每个结点只有一个后继。在有些情况下，一个结点可能有多个后继。树（tree）可以描述这类非线性结构，二叉树（Binary Tree)的递归定义如下：二叉树要么为空，要么由根节点（root）、左子树（left subrree）和右子树（right subtree）组成，而左子树和右子树分别是一颗二叉树。注意，在计算机中，树一般是“倒置”的，即根在上，叶子在下。本文将介绍二叉树的创建及层序遍历。
二叉树层次遍历算法
weixin_45683301的博客
09-27 6386
代码区
（数据结构）二叉树层次遍历
weixin_51927215的博客
03-30 1万+
二叉树层次遍历 二叉树层次遍历的实现思想是：通过队列数据结构，从树的根结点开始，依次将其左孩子和右孩子入队；而后每次队列中一个结点出队，都将其左孩子和右孩子入队，直到树中所有结点都出队，出队结点的先后顺序就是层次遍历的最终结果 图1 二叉树 以上图 1 为例，层次遍历的过程如下： 首先，根结点 1 入队 根结点 1 出队，出队的同时，将左孩子 2 和右孩子 3 分别入队 队头结点 2 出队，出队的同时，将结点 2 的左孩子 4 和右孩子 5 依次入队 队头结点 3 ...
二叉树的遍历（七种方法）
兔子王
10-23 1万+
本章主要通过运用递归与非递归方法分别对二叉树进行遍历 主要分先序遍历、中序遍历、后序遍历以及层次遍历四种情况进行讨论
二叉树：层次遍历算法（自上而下，从左到右）
花间半盘棋
11-15 1万+
分析：层次遍历（LeverlOrder）就是一层一层遍历，层次遍历需要借助队列来完成，队列：先进先出（FIFO）。 如图有一棵二叉树，按照层次遍历最终的结果就是ABCDEFG，首先将根结点A入队列。 然后根结点出队，并访问A结点，发现A结点既有左孩子也有右孩子，那么就分别将左右孩子入队，此时队列中有BC。 A的左右孩子都入队了，然后将队头结点B出队并访问，此时序列为AB，B有左右孩子，所以将B的左右孩子DE入队，队中此时有CDE。 然后队头结点C出队并访问，C有左右孩子，所以将C的左右孩子FG入队。此时
C++数据结构与算法二叉树的层序遍历代码及注释
04-02
本文将深入探讨C++中的数据结构之一——二叉树，并重点讲解如何实现二叉树的层序遍历。层序遍历，也称为宽度优先搜索（BFS），是一种在二叉树中遍历节点的常用方法，它按照从上至下、从左到右的顺序逐层访问所有节点...
二叉树遍历——前中后序
07-18
`二叉树.txt` 文件可能包含了一棵二叉树的节点信息，如节点值和它们的链接关系，可以用于测试和演示各种遍历算法。 在实际应用中，二叉树遍历不仅局限于这些基本形式，还可以有层次遍历（Level Order Traversal）...
数据结构（C++）上课笔记——二叉树的C++实现(2020-5-11) .doc
05-21
`BinaryTree`类提供了多种方法，包括构造函数、查询树的深度、获取节点个数、判断树是否为空、查找节点的双亲、左右子节点、插入和删除元素、以及四种遍历方法（前序、中序、后序和层次遍历）。这些方法都是二叉树...
剑指offer面试题（7）——重建二叉树
06-14
【重建二叉树】是计算机科学中一个经典的数据结构问题，主要出现在算法和数据结构的面试中，尤其在像《剑指Offer》这样的面试指南中经常出现。这道题目要求根据给定的前序遍历和中序遍历序列来重建原始的二叉树结构...
c++实现二叉树的4种遍历（递归和非递归）（csdn）————程序.pdf
12-01
有四种主要的遍历方法：前序遍历、中序遍历、后序遍历和层次遍历。这些遍历方式在理解和操作二叉树时至关重要，尤其在算法设计和数据结构处理中。 1. **前序遍历**：首先访问根节点，然后遍历左子树，最后遍历右子...
【数据结构】二叉树的层序遍历(BFS)
Colorful___的博客
10-06 7604
层序遍历是一种广度优先搜索的遍历方式，适用于树结构。通过利用队列实现层序遍历，我们可以按照从上到下、从左到右的顺序逐层遍历树中的节点。层序遍历广泛应用于树的分析、最短路径寻找、二叉树的构建等场景。掌握层序遍历的原理和实现方法将对解决相关问题非常有帮助。
二叉树遍历之层次遍历算法入门详解
sunnyoldboy博客
07-22 6085
层次遍历的原理很简单，总结为一句话就是“从上到下，从左到右”，就是从树根开始逐层访问二叉树的结点，每一层按照从左到右的次序进行访问。 为了方便实现层次遍历，可以引入队列来缓存二叉树上的所有结点，出队列则访问。 入队列的规则：树根先入，之后立刻出队列并访问，然后树根的左、右子树树根依次入队列，之后依次出队列。没出来一个结点，都将其左、右子树树根依次入队（为空者不入）。.........
二叉树的层次遍历（C语言）
热门推荐
chenshengnanii的博客
05-24 2万+
一、二叉树的概念以及结构 二叉树是n(n>=0)个节点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根节点和两棵互不相交的、分别称为根节点的左子树和右子树组。 二、二叉树的遍历图解 先序遍历 中序遍历 后序遍历 层次遍历 ...
二叉树的五种遍历方式
weixin_47382783的博客
03-29 1万+
目录 1、前序遍历 （1）递归实现前序遍历 （2）非递归实现前序遍历 2、中序遍历 （1）递归实现中序遍历 （2）非递归实现中序遍历 3、后序遍历 （1）递归实现后序遍历 （2）非递归实现后序遍历 4、层序遍历 二叉树是一种重要的数据结构，其遍历方式分为：深度遍历和广度遍历，深度遍历有前序、中序以及后序三种遍历方法，广度遍历即就是层次遍历。如下图： class TreeNode{ int val; TreeNode left; TreeNode ..
二叉树层次遍历算法代码实现c语言
04-19
以下是C语言实现二叉树层次遍历算法的示例代码： ```c #include <stdio.h> #include <stdlib.h> // 二叉树结点结构体 typedef struct node { int data; // 结点数据 struct node *left; // 左子树结点指针 struct node *right; // 右子树结点指针 } Node, *Tree; // 队列结构体 typedef struct queue { Tree data; // 队列元素数据 struct queue *next; // 下一个队列元素指针 } Queue, *Stack; // 初始化队列 void initQueue(Queue **queue) { *queue = (Queue *) malloc(sizeof(Queue)); (*queue)->next = NULL; } // 判断队列是否为空 int isQueueEmpty(Queue *queue) { return (queue->next == NULL); } // 入队 void enqueue(Queue *queue, Tree data) { Queue *newNode = (Queue *) malloc(sizeof(Queue)); newNode->data = data; newNode->next = NULL; Queue *p = queue; while (p->next != NULL) { p = p->next; } p->next = newNode; } // 出队 Tree dequeue(Queue *queue) { Queue *p = queue->next; Tree data = p->data; queue->next = p->next; free(p); return data; } // 二叉树层次遍历 void levelOrderTraversal(Tree tree) { if (!tree) { return; } Queue *queue; initQueue(&queue); enqueue(queue, tree); while (!isQueueEmpty(queue)) { Tree node = dequeue(queue); printf("%d ", node->data); if (node->left) { enqueue(queue, node->left); } if (node->right) { enqueue(queue, node->right); } } } // 测试代码 int main() { // 构造二叉树 Tree tree = (Tree) malloc(sizeof(Node)); tree->data = 1; tree->left = (Tree) malloc(sizeof(Node)); tree->left->data = 2; tree->left->left = NULL; tree->left->right = NULL; tree->right = (Tree) malloc(sizeof(Node)); tree->right->data = 3; tree->right->left = NULL; tree->right->right = NULL; tree->left->left = (Tree) malloc(sizeof(Node)); tree->left->left->data = 4; tree->left->left->left = NULL; tree->left->left->right = NULL; tree->right->right = (Tree) malloc(sizeof(Node)); tree->right->right->data = 5; tree->right->right->left = NULL; tree->right->right->right = NULL; // 层次遍历 levelOrderTraversal(tree); return 0; } ``` 以上是一个基于队列实现的二叉树层次遍历算法的 C 语言示例代码。在该示例代码中，主要包括了初始化队列、判断队列是否为空、入队、出队等队列操作函数，以及二叉树层次遍历函数 levelOrderTraversal。在 levelOrderTraversal 函数中，我们首先将根节点入队，然后进行循环遍历，每次出队一个结点，并将该结点的左右子树入队，直到队列为空为止，期间找到的各个结点就是二叉树的层次遍历结果。
评论 31
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值