数据结构之二叉树的前中后序遍历以及层序遍历

最新推荐文章于 2022-12-03 22:58:53 发布
最新推荐文章于 2022-12-03 22:58:53 发布
阅读量143 收藏 2
点赞数 3
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64361522/article/details/127877519
版权

学习目标：读完这篇博客搞定二叉树的前中后序以及层序遍历

首先：你应该明白什么是二叉树，下面这幅图就是一个完全二叉树

其实所谓的二叉树就是一个节点有小于等于二个分支的树，可以没有分支，可以有1条分支，可以有两条分支，这便是二叉树

  • 还有就是我们要理解二叉树的分治，以及递归，我们要把大事化小，一层一层来解决！

学习内容：二叉树的前中后以及层序遍历的代码实现

我们先来学习一下前序遍历吧，首先什么是前序遍历呢？其实二叉树有根，左子树以及右子树，而二叉树的前序遍历其实就是先遍历根节点在遍历左子树最后在遍历右子树，好讲了这么多都不如上代码来的实际！

 

struct node
{
    datatype data;
    struct node* plch;
    struct node* prch;
};

struct node* create_bree(void)
{
    struct node* pa = malloc(sizeof(struct node));
    struct node* pb = malloc(sizeof(struct node));
    struct node* pc = malloc(sizeof(struct node));
    struct node* pd = malloc(sizeof(struct node));
    struct node* pe = malloc(sizeof(struct node));
    struct node* pf = malloc(sizeof(struct node));
    struct node* pg = malloc(sizeof(struct node));
    struct node* ph = malloc(sizeof(struct node));
    struct node* pi = malloc(sizeof(struct node));

    pa->data = 'a';
    pb->data = 'b';
    pc->data = 'c';
    pd->data = 'd';
    pe->data = 'e';
    pf->data = 'f';
    pg->data = 'g';
    ph->data = 'h';
    pi->data = 'i';
    
    pa->plch = pb;
    pa->prch = pc;

    pb->plch = pd;
    pb->prch = pe;
    
    pc->plch = NULL;
    pc->prch = pf;

    pd->plch = NULL;
    pd->prch = NULL;
    
    pe->plch = pg;
    pe->prch = ph;

    pf->plch = pi;
    pf->prch = NULL;

    pg->plch = NULL;
    pg->prch = NULL;
    
    ph->plch = NULL;
    ph->prch = NULL;
    
    pi->plch = NULL;
    pi->prch = NULL;

    return pa;
}
//先序遍历
void privot(struct node* proot)
{
    if (proot != NULL)
    {
        if (proot != NULL)
            printf("%c-->", proot->data);
        if (proot->plch != NULL)
            privot(proot->plch);
        if (proot->prch != NULL)
            privot(proot->prch);
    }
}

int main()
{
    struct node* pa = create_bree();
    privot(pa);
    printf("\n");

    return 0;

}

 其实中序遍历和后序遍历的原理跟前序遍历的原理是差不多的，中序遍历的原理就是先遍历左子树在遍历根在遍历右子树，那么后序遍历的原理是什么呢？哈哈哈其实也是差不多的啦。就是先遍历左子树在遍历右子树，在遍历根噢，好啦直接上代码吧！

void inorderprint(struct node* proot)
{
    if (proot != NULL)
    {
        if (proot->plch != NULL)
            inorderprint(proot->plch);
        if (proot != NULL)
            printf("%c-->", proot->data);
        if (proot->prch != NULL)
            inorderprint(proot->prch);
    }
}
void houxuprint(struct node* proot)
{
    if (proot != NULL)
    {
        if (proot->plch != NULL)
            houxuprint(proot->plch);
        if (proot->prch != NULL)
            houxuprint(proot->prch);
        if (proot != NULL)
            printf("%c-->", proot->data);
    }
}

最后的话，就来到最重点的时候了哦，就要来写我们的层序遍历了，层序遍历的算法我这里利用了链式队列来实现的，其实层序遍历就是一层一层遍历，从左到右遍历完一层就直接往下一层继续遍历。接下来就是放全部的代码啦！

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <assert.h>

typedef struct node* QDataType;

typedef struct QueueNode
{
    struct QueueNode* next;
    QDataType data;
}QNode;

typedef struct Queue
{
    QNode* head;
    QNode* tail;
}Queue;

void QueueInit(Queue* pq)
{
    assert(pq);
    pq->head = pq->tail = NULL;
}
void QueueDestory(Queue* pq)
{
    assert(pq);
    QNode* cur = pq->head;
    while (cur)
    {
        QNode* next = cur->next;
        free(cur);
        cur = next;
    }
    pq->head = pq->tail = NULL;
}
//队尾入
void QueuePush(Queue* pq, QDataType x)
{
    assert(pq);
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL)
    {
        printf("malloc fail\n");
        exit(-1);
    }
    newnode->data = x;
    newnode->next = NULL;
    if (pq->tail == NULL)
    {
        pq->head = pq->tail = newnode;
    }
    else
    {
        pq->tail->next = newnode;
        pq->tail = newnode;
    }
}
void QueuePop(Queue* pq)
{
    assert(pq);
    assert(pq->head);
    if (pq->head->next == NULL)
    {
        free(pq->head);
        pq->head = pq->tail = NULL;
    }
    else
    {
        QNode* next = pq->head->next;
        free(pq->head);
        pq->head = next;
    }

}
QDataType QueueFront(Queue* pq)
{
    assert(pq);
    assert(pq->head);

    return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
    assert(pq);
    assert(pq->head);

    return pq->tail->data;
}
int QueueSize(Queue* pq)
{
    assert(pq);
    int size = 0;
    QNode* cur = pq->head;
    while (cur)
    {
        ++size;
        cur = cur->next;
    }
    return size;
}
bool QueueEmpty(Queue* pq)
{
    assert(pq);
    return pq->head == NULL;
}
typedef char datatype;

struct node
{
    datatype data;
    struct node* plch;
    struct node* prch;
};

struct node* create_bree(void)
{
    struct node* pa = malloc(sizeof(struct node));
    struct node* pb = malloc(sizeof(struct node));
    struct node* pc = malloc(sizeof(struct node));
    struct node* pd = malloc(sizeof(struct node));
    struct node* pe = malloc(sizeof(struct node));
    struct node* pf = malloc(sizeof(struct node));
    struct node* pg = malloc(sizeof(struct node));
    struct node* ph = malloc(sizeof(struct node));
    struct node* pi = malloc(sizeof(struct node));

    pa->data = 'a';
    pb->data = 'b';
    pc->data = 'c';
    pd->data = 'd';
    pe->data = 'e';
    pf->data = 'f';
    pg->data = 'g';
    ph->data = 'h';
    pi->data = 'i';
    
    pa->plch = pb;
    pa->prch = pc;

    pb->plch = pd;
    pb->prch = pe;
    
    pc->plch = NULL;
    pc->prch = pf;

    pd->plch = NULL;
    pd->prch = NULL;
    
    pe->plch = pg;
    pe->prch = ph;

    pf->plch = pi;
    pf->prch = NULL;

    pg->plch = NULL;
    pg->prch = NULL;
    
    ph->plch = NULL;
    ph->prch = NULL;
    
    pi->plch = NULL;
    pi->prch = NULL;

    return pa;
}
//先序遍历
void privot(struct node* proot)
{
    if (proot != NULL)
    {
        if (proot != NULL)
            printf("%c-->", proot->data);
        if (proot->plch != NULL)
            privot(proot->plch);
        if (proot->prch != NULL)
            privot(proot->prch);
    }
    
}
void inorderprint(struct node* proot)
{
    if (proot != NULL)
    {
        if (proot->plch != NULL)
            inorderprint(proot->plch);
        if (proot != NULL)
            printf("%c-->", proot->data);
        if (proot->prch != NULL)
            inorderprint(proot->prch);
    }
}
void houxuprint(struct node* proot)
{
    if (proot != NULL)
    {
        if (proot->plch != NULL)
            houxuprint(proot->plch);
        if (proot->prch != NULL)
            houxuprint(proot->prch);
        if (proot != NULL)
            printf("%c-->", proot->data);
    }
}

void cengxubianli(struct node* proot)
{
    if (proot == NULL)
    {
        return;
    }
    Queue pq;
    QueueInit(&pq);
    QueuePush(&pq, proot);
    while (!QueueEmpty(&pq))
    {
        struct node* head = QueueFront(&pq);                                 
        QueuePop(&pq);
        printf("%c ", head->data);
        if (head->plch != NULL)
        {
            QueuePush(&pq, head->plch);
        }
        if (head->prch != NULL)
        {
            QueuePush(&pq, head->prch);
        }
    }
    printf("\n");
}
int main()
{
    struct node* pa = create_bree();
    privot(pa);
    printf("\n");
    inorderprint(pa);
    printf("\n");
    houxuprint(pa);
    printf("\n");
    cengxubianli(pa);
    return 0; 
}
 

 

好啦本次的代码就全部实现完啦，祝大家学习快乐！ 

M malloc
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
正弦定理的博客
12-09 35万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
【数据结构】二叉树前中后序遍历、层序遍历（递归实现）
Begin
07-05 890
这里使用前序遍历方式建立二叉树 主要介绍：递归实现二叉树建立，前序、中序、后续、层序遍历 ，求二叉树深度及节点个数  本文使用序列：array[10] = { 1, 2, 3, -1, -1, 4, -1, -1, 5, 6 }; 前序遍历算法： 若二叉树为空，则算法结束，否则： 1）先访问根节点   2）前序遍历访问左子树   3）前序遍历访问右子树 前序遍历结果：1 2 3
数据结构---后序遍历
yinhua405的博客
05-26 398
typedef struct node {  ElemType data;  struct node *lchild;  struct node *rchild; }BTNode; void PostOrder(BTNode *b) {  if(b != NULL)  {   PostOrder(b->lchild);   PostOrder(b->rchild);   p
数据结构的先、中、后序遍历
wuxiaoze_的博客
12-01 242
typedef struct TreeNode { int data; TreeNode * left; TreeNode * right; TreeNode * parent; }TreeNode; void pre_order(TreeNode * Node)//前序遍历递归算法 { if(Node == NULL) return; printf("%d ", Node->data);//显示节点数据，可以更改为其他操作。...
数据结构 树（二） 先序遍历 中序遍历 后序遍历
zhengdajie的博客
04-18 199
。。
算法与数据结构：前序、中序、后序遍历（python实现）
weixin_38730719的博客
04-09 441
遍历思想为： 前序遍历：根结点 ---> 左子树 ---> 右子树 中序遍历：左子树--->根结点---> 右子树 后序遍历：左子树 ---> 右子树---> 根结点 首先说下递归的思想：只专注于当前的一个小的步骤，控制号结束条件即可。所以对于遍历来说只需要按照上述规则打印即可。 前序遍历： class Tree(): def __...
数据结构——二叉树先序、中序、后序三种遍历
legendarykk的博客
07-17 3万+
二叉树
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
09-19
本文将深入探讨Python中的二叉树及其遍历方法，包括前序遍历、中序遍历、后序遍历以及层序遍历。通过具体的代码示例，我们将更好地理解这些遍历方法的工作原理和应用场景。 #### 二、二叉树基础知识回顾 二叉树是由...
二叉树的后序遍历
CV前沿
04-03 4万+
二叉树的后序遍历的记忆法则是“左右根"，即先遍历左子树节点，再遍历右子树节点，最后遍历根节点。 以上图为例，后序遍历的结果是【D, E, B, F, G, C, A】 一、解题思路：递归 递归是我们实现前中后序遍历最常用的方法。 什么问题可以采用递归求解呢？ 需要满足三个条件： 一个问题的解可以分解为若干个子问题的解； 这个问题与分解的子问题，除了数据规模不同外，求解思路相同 存在递归终止条件。 那么在知道一个问题可以采用递归实现之后，如何写出递归代码呢？ 关键在于能写出递归公式，找到终止条件。 .
Java中的二叉树，前中后序遍历的递归和迭代写法。
回水的博客
06-15 1179
文章目录一、树是什么？树的特点二、二叉树1.概念及特点2.读入数据总结 一、树是什么？ 树是一种非线性的数据结构，它是由n(n >= 0)个有限结点组成的一个具有层次关系的集合。(线性数据结构就是：线性表，数组，栈，链表，队列，字符串…元素之间逻辑上一个挨着一个，呈值直线排列)把它叫做树是因为它看起来像一颗倒着的树，意思就是根朝上，叶子朝下。 树的特点 有一个特殊的结点，称为根节点，根节点没有前驱结点。 除根节点外，其余节点被分成M(M > 0) 个互不相交的集合T1、T2、…、Tm,其中
数据结构——二叉树的先中后序遍历
最新发布
weixin_64084604的博客
12-03 1万+
——本节内容为Bilibili王道考研《数据结构》P43~P45视频内容笔记。 目录一、二叉树的先中后序遍历1.先中后序遍历2.举例 3.先中后序遍历和前中后缀的关系4.代码实现5.求遍历序列6.应用：求树的深度二、二叉树的层次遍历1.层次遍历2.算法思想：3.算法演示：4.代码实现：三、由遍历序列构造二叉树1.遍历序列构造二叉树2.前序+中序3.后序+中序4.层序+中序（1）二叉树的递归特性： ①要么是个空二叉树； ②要么是由“根结点+左子树+右子树”组成的二叉树。（2）基于此
数据结构（五）：前序遍历、中序遍历、后序遍历
qq_41623154的博客
04-29 1万+
前序、中序和后序三种表达式，是针对同一个表达式的不同方式的表示。 在讲三种表达式之前，我们先看下二叉树的前序、后序和中序遍历。遍历下面这个二叉树，分别以前中后三种遍历方式，写出结点的顺序。 前序遍历：顺序“根左右”或“中左右” ①遍历根节点 ②遍历根结点的左子结点：如果左结点不是叶节点，则以当前结点开始，重新从第一步开始循环 ③遍历根节点的右子结点：如果右结点不是叶节点，则以当前结点开始，重新...
数据结构——树（5）——树的先序，中序，后序,层次遍历
redAnt的博客
01-25 3506
树的存储结构 之前我们提到过堆是一棵特殊的树，在堆的存储方式中，我们选择了数组的方式去存储。因为只要知道一个节点的位置我们就能找到其他的节点的位置。但是前提是堆是一棵完全二叉树。树的结构多种多样，没人规定说一个节点只能有一个孩子。 我们先看下图，一个最简单的二叉树： 怎么表达？看到箭头，我们应该立马反应过来一个基本的工具，没错就是指针，应该立马反应过来一个数据结构，那就是链表！ 对
数据结构基础15：二叉树的前序、中序和后序遍历
何哥的博客
01-28 4357
前言：到目前为止，我们已经介绍了线性数据结构和表数据机构（哈希表）。这些数据机构一般都不适合表示具有层级结构的数据。在层次化的元素之间有祖先—后代、上级—下属、整体—部分以及其他类似的关系。 一、树的介绍 1、树的定义： 树状图是一种数据结构，它是由n（n&gt;=0）个结点组成一个具有层次关系的有穷集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。n=0...
数据结构之二叉树的前序遍历、中序遍历、后序遍历、层序遍历
热门推荐
gongwq的博客
10-21 5万+
最近也是在准备笔试，由于没有系统的学过数据结构，所以每次在考到二叉树的遍历的时候都是直接跪，次数多了也就怒了，前些天也是准备论文没时间整这些，现在提交了，算是稍微轻松点了，所以花了半天的时间来学了下二叉树。现在记下来，以便后序查阅。 一、二叉树的遍历概念     1.  二叉树的遍历是指从根结点触发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。 (1). 前(
数据结构之二叉树的遍历,前序遍历,中序遍历,后序遍历
是我
07-24 900
二叉树的遍历,分为前序遍历,中序遍历,后序遍历,对这几种遍历总是有点模糊,今天做一下详细的笔记吧 前序遍历：A B C D E F G H K,遍历指导:从根节点开始,先左后右 中序遍历：B D C A E H G K F,遍历指导,从左节点开始,一直遍历到无左节点,然后回溯。（先左后右） 后序遍历：D C B H K G F E A，遍历指导，先左后右，最后根 ...
数据结构之前序遍历，中序遍历，后序遍历
流离的专栏
07-06 5072
  前序遍历-》首先访问根结点，                    然后遍历左子树，                    最后遍历右子树。                    在遍历左、右子树时，仍然先访问根结点，然后遍历左子树，最后遍历右子树。 中序遍历-》首先遍历左子树，                    然后访问根结点，                  
数据结构与算法之二叉树的先序遍历，中序遍历，后序遍历
努力努力再努力L
06-28 2453
数据结构与算法之二叉树的先序遍历，中序遍历，后移遍历 目录 实现二叉树的先序，中序，后序遍历，包括递归方式和非递归方式 在二叉树中找到一个节点的后继节点 1. 实现二叉树的先序，中序，后序遍历，包括递归方式和非递归方式 1. 先序遍历，中序遍历，后序遍历递归版 //先序遍历递归版 public static void preOrderRecur(Node head) { ...
数据结构---二叉树（前中后序遍历以及查找）
qq_40955824的博客
08-07 2241
1. 二叉树与其他数据结构的比较 1.1数组存储方式的分析 优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。 缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低 1.2链式存储方式的分析 优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可， 删除效率也很好)。 缺点：在进行检索时，效率仍然...
递归与迭代实现：二叉树前中后序遍历详解
二叉树遍历是计算机科学中处理二叉树数据结构的重要概念，它涉及到对树中每个节点的有序访问。主要的遍历方式包括前序遍历、中序遍历和后序遍历，以及额外的层序遍历。这些遍历方法各有其特点和应用场景。 1. 前序...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

M malloc

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

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

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

打赏作者

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

抵扣说明：

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

余额充值