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

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

其实所谓的二叉树就是一个节点有小于等于二个分支的树,可以没有分支,可以有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; 
}

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

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

  1. 【数据结构】二叉树的前中后序遍历

    二叉树的三种遍历 1. 创建一棵简单的二叉树 1.1 二叉树结构体实现 1.2 创造一个二叉树结点的函数 1.3 手动创造一棵二叉树 2.为什么要遍历? 3.最重要的知识:由二叉树引出的子问题分析 4 ...

  2. 【Java数据结构】二叉树的前中后序遍历(递归和非递归)

    二叉树的遍历 递归做法 前序遍历 中序遍历 后序遍历 非递归 前序遍历 中序遍历 后序遍历 二叉树遍历是二叉树的一种重要操作 必须要掌握 二叉树的遍历可以用递归和非递归两种做法来实现 递归做法 前序遍 ...

  3. 二叉树(前中后序递归非递归遍历,层次遍历

    #ifndef _BITREE_H  #define   _BITREE_H  #include "Stack.h" #include "Queue.h" te ...

  4. 二叉树的前,中,后序遍历(思路分析) [Java][数据结构]

    二叉树的前,中,后序遍历(思路分析) 前序遍历: 先输出父节点, 再遍历左子树和右子树 中序遍历: 先遍历左子树, 再输出父节点,再遍历右子树 后序遍历: 先遍历左子树,再遍历右子树,最后输出父节点 ...

  5. 深入理解二叉树的前中后序

    一.问题 二叉树的前中后序遍历到底是什么,仅仅是三个顺序不同的 List 吗?为什么多叉树没有中序遍历? 二.遍历框架 所谓二叉树遍历是按某种特定规则,依次对二叉树中的节点进行相应的操作,并且每个节点 ...

  6. Java二叉树的前中后序遍历

    Java二叉树的前中后序遍历 1.前序遍历 1.1前序遍历概念 1.2前序遍历习题 2.中序遍历 2.1中序遍历概念 2.2中序遍历习题 3.后续遍历 3.1后序遍历概念 3.2后序遍历习题 大家好, ...

  7. 数据结构与算法(java):树-二叉树(二叉查找树(BST)、线索化二叉树、哈夫曼树、平衡二叉树【AVL】、二叉树的前中后序遍历)

    二叉树 1.定义 二叉树 就是度不超过2的树(每个结点最多只有两个子结点).如图 2.特殊二叉树 满二叉树 当二叉树的每一个层的结点树都达到最大值,则这个二叉树就是满二叉树. 完全二叉树 叶结点只能出 ...

  8. 二叉树的前中后序遍历之迭代法(非统一风格迭代方式)

    文章目录 前言 一.前序遍历(迭代法) 二.中序遍历(迭代法) 三.后序遍历(迭代法) 总结 前言 「递归的实现就是:每一次递归调用都会把函数的局部变量.参数值和返回地址等压入调用栈中」,然后递归返回 ...

  9. 二叉树的前中后序遍历(考试常考)

    二叉树遍历的概念 二叉树的遍历是按某种规则对二叉树的每个节点均只被访问一次,根据根节点访问位置的不同分为三种:先序遍历(根左右).中序遍历(左根右).后序遍历(左右根).         由于树是通过 ...

最新文章

  1. python filter过滤器的使用_如何在Python 3中使用过滤器、映射和精简
  2. java并发编程基础—生命周期与线程控制
  3. Sql Server的弱口令入侵测试以及防范
  4. 物联网 android前景,物联网现状及未来前景分析
  5. 阿里云函数计算 FC再次荣获最受观众喜爱奖
  6. Python——常用模块
  7. 算法设计与分析——递归与分治策略——全排列
  8. 酷冷至尊官方psu计算工具_酷冷至尊为Raspberry Pi推出Pi Case 40机壳,提供被动散热、卖27美元起...
  9. 大开眼界百度云盘2018_文化差异的大开眼界
  10. extra增强延迟加载
  11. 第一次c语言课程设计——学生选课管理系统
  12. Windows小技巧 – Win+R提高Windows使用效率
  13. 小米进军欧洲智能手机市场:一面是狂欢,一面是考验...
  14. 利用selenium webdriver下载不同类型的文件(pdf,txt等等)
  15. 怎样才能赢得用户------由360与腾讯之争引发的思考
  16. python实现1分钟内股价波动邮件提示
  17. html用九张图片做出九宫图,用ps如何将九张照片做成九宫格?
  18. 无人机——电调篇(二)
  19. 毕业设计 python的微信公众平台机器人
  20. 如何统计多个Excel文件中的信息,统计多个工作簿中的数据,统计多个表格中相同的条,统计多个表格的和等等

热门文章

  1. 王海良:开源引领信息技术创新
  2. unity3d 怎么生成网页版_Unity3D 基础教程3D网页游戏场景打包与加载
  3. (转)刹车离合同时踩非常危险
  4. 使用C#开发了一个RPG角色扮演类的小游戏^_^
  5. 11、OpenGL - 混合(颜色混合)
  6. java贪吃蛇博客带图片_java课程设计--贪吃蛇小队博客
  7. 小红书-内卖秒杀项目总结
  8. Linux环境下安装onlyoffice
  9. unity 调用Anidroid 相册 选取图片裁剪
  10. fooview辅助功能 shell_列出所有Bash Shell内置命令的方法示例