数据结构之二叉树的前中后序遍历以及层序遍历
学习目标：读完这篇博客搞定二叉树的前中后序以及层序遍历
首先：你应该明白什么是二叉树，下面这幅图就是一个完全二叉树
其实所谓的二叉树就是一个节点有小于等于二个分支的树，可以没有分支，可以有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.2 创造一个二叉树结点的函数 1.3 手动创造一棵二叉树 2.为什么要遍历? 3.最重要的知识:由二叉树引出的子问题分析 4 ...
- 【Java数据结构】二叉树的前中后序遍历(递归和非递归)
二叉树的遍历 递归做法 前序遍历 中序遍历 后序遍历 非递归 前序遍历 中序遍历 后序遍历 二叉树遍历是二叉树的一种重要操作 必须要掌握 二叉树的遍历可以用递归和非递归两种做法来实现 递归做法 前序遍 ...
- 二叉树（前中后序递归非递归遍历，层次遍历
#ifndef _BITREE_H #define _BITREE_H #include "Stack.h" #include "Queue.h" te ...
- 二叉树的前,中,后序遍历(思路分析) [Java][数据结构]
二叉树的前,中,后序遍历(思路分析) 前序遍历: 先输出父节点, 再遍历左子树和右子树 中序遍历: 先遍历左子树, 再输出父节点,再遍历右子树 后序遍历: 先遍历左子树,再遍历右子树,最后输出父节点 ...
- 深入理解二叉树的前中后序
一.问题 二叉树的前中后序遍历到底是什么,仅仅是三个顺序不同的 List 吗?为什么多叉树没有中序遍历? 二.遍历框架 所谓二叉树遍历是按某种特定规则,依次对二叉树中的节点进行相应的操作,并且每个节点 ...
- Java二叉树的前中后序遍历
Java二叉树的前中后序遍历 1.前序遍历 1.1前序遍历概念 1.2前序遍历习题 2.中序遍历 2.1中序遍历概念 2.2中序遍历习题 3.后续遍历 3.1后序遍历概念 3.2后序遍历习题 大家好, ...
- 数据结构与算法（java）：树-二叉树（二叉查找树（BST）、线索化二叉树、哈夫曼树、平衡二叉树【AVL】、二叉树的前中后序遍历）
二叉树 1.定义 二叉树 就是度不超过2的树(每个结点最多只有两个子结点).如图 2.特殊二叉树 满二叉树 当二叉树的每一个层的结点树都达到最大值,则这个二叉树就是满二叉树. 完全二叉树 叶结点只能出 ...
- 二叉树的前中后序遍历之迭代法（非统一风格迭代方式）
文章目录 前言 一.前序遍历(迭代法) 二.中序遍历(迭代法) 三.后序遍历(迭代法) 总结 前言 「递归的实现就是:每一次递归调用都会把函数的局部变量.参数值和返回地址等压入调用栈中」,然后递归返回 ...
- 二叉树的前中后序遍历(考试常考)
二叉树遍历的概念 二叉树的遍历是按某种规则对二叉树的每个节点均只被访问一次,根据根节点访问位置的不同分为三种:先序遍历(根左右).中序遍历(左根右).后序遍历(左右根). 由于树是通过 ...
最新文章
- Spring Framework------version4.3.5-----Reference学习心得-----总结
- LeetCode: 2_Add Two Numbers | 两个链表中的元素相加 | Medium
- Hibernate配置属性详解
- html多个单元格合并单元格内容,excel怎样快速把多个单元格内容合并 合并多个单元格内容的设置方法...
- http抓包神器：Charles for Mac 特别版v4.6
- 二分查找详解——弄懂二分思想的重要性！
- linux 无损拆分分区 asm,利用UDEV SCSI Rules配置linux下的ASM
- mysql 分页_MySQL如何实现分页查询
- 北京市常用电话号码表
- 服务器芯片成本,2021年全球服务器行业成本结构及出货量分析[图]
- 联想笔记本电脑主板分析与维修（型号G50-70M版号NM-A273） 问题：按电源开关不开机无反应，充电指示灯不亮
- DataGrip离线安装驱动
- uniapp 开发微信小程序，通过高德SDK获取当位置详细信息
- 抖音为何要自研芯片？
- nginx配置连接数及限制客户端请求
- 学习Direct3D的好地方
- 人工衍射透镜的设计与分析
- 如何进入服务器系统,服务器系统怎么进入
- Ardunio开发——水泵操作过程
- 常见外贸英文缩写（中）