数据结构（五）——队列、树

最新推荐文章于 2023-03-16 17:08:22 发布
最新推荐文章于 2023-03-16 17:08:22 发布
阅读量348 收藏
点赞数 3
分类专栏： # 嵌入式数据结构 文章标签： 数据结构 链表
原文链接：https://blog.csdn.net/m0_52592798/article/details/122957754
版权

文章目录

一、队列

1.1 队列的概念

队列的性质：先进先出（FIFO）
队列的操作
入队
出队

1.2 链式队列

为了实现队列的先进先出的原理，链式存储里面可以采用头插法和尾删法或者尾插法和头删法实现功能，但是尾插和尾删都需要将链表遍历一次，效率比较低
所以，我们可以定义两个指针变量，一个front保存头结点的地址，另一个rear保存最后一个结点的地址
入队操作时将新结点插入到rear对应的结点的后面，然后rear保存最后一个结点的地址，出队操作就是将头结点后面的结点删除。
在这里插入图片描述

1.2.1 linkqueue.h

//头文件
#ifndef _LINKQUEUE_H_
#define _LINKQUEUE_H_
#include <stdio.h>
#include <stdlib.h>

typedef int DataType;
typedef struct node  //定义结点结构体
{
    DataType data;
    struct node *next;
}node;

typedef struct  //定义结构体便于返回操作链式队列的两个指针
{
    node *front;  //保存头结点地址
    node *rear;   //每次保存最后一个结点的地址
}linkqueue;
//创建一个空的队列
linkqueue *LinkQueueCreate();
//入队
void LinkQueueInput(linkqueue *q, DataType value);
//出队
DataType LinkQueueOutput(linkqueue *q);
#endif

1.2.2 linkqueue.c

//linkqueue.c
#include "linkqueue.h"
//创建一个空的队列
linkqueue *LinkQueueCreate()
{
    //创建两个指针
    linkqueue *q = (linkqueue *)malloc(sizeof(linkqueue));
    //创建一个头结点并且让next指针指向NULL
    q->front = (node *)malloc(sizeof(node));
    q->rear = q->front;
    q->front->next = NULL;


    return q;
}


//入队
void LinkQueueInput(linkqueue *q, DataType value)
{
    //申请一个新的结点并且赋值
    node *tmp = (node *)malloc(sizeof(node));
    tmp->data = value;
    tmp->next = NULL;


    //将新节点插入到rear对应的结点的后面
    //rear结点的指针域保存新结点的地址
    q->rear->next = tmp;
    //新节点的指针域保存NULL
    tmp->next = NULL;  
    q->rear = tmp;
    return;
}
//出队
DataType LinkQueueOutput(linkqueue *q)
{
    if(q->front->next == NULL)
    {
        printf("队列为空！\n");
        return (DataType)-1;
    }
    //将front对应的结点后面的结点删除
    node *tmp = q->front->next;
    q->front->next = tmp->next;
    DataType value = tmp->data;

    free(tmp);
    tmp = NULL;
    //当最后一个结点删除之后，需要将rear指针指向头结点
    if(q->front->next == NULL)
    {
        q->rear = q->front;
    }
    return value;
}

1.3 顺序队列（循环队列）

在这里插入图片描述

1.3.1 sequeue.h

//头文件
#ifndef _SEQUEUE_H_
#define _SEQUEUE_H_
#include <stdio.h>
#include <stdlib.h>

#define NUM 32
#define N (NUM + 1)
typedef int DataType;
typedef struct{  //定义结构体
    DataType data[N];
    int front;  //保存出队的元素下标
    int rear;  //保存入队的位置
}sequeue;

//创建一个空的循环队列
//判断队列是否为满
//判断队列是否为空
//入队
//出队
#endif

1.3.2 sequeue.h

//功能函数
#include "sequeue.h"
//创建一个空的循环队列
sequeue* SequeueCreate()
{
    //申请空间
    sequeue *sq = (sequeue *)malloc(sizeof(sequeue));
    //初始状态让front和rear都保存0,标识为空
    sq->front = sq->rear = 0;


    return sq;
}
//判断队列是否为满
int SequeueIsFull(sequeue *sq)
{
    return (sq->rear + 1) % N == sq->front ? 1 : 0;
}
//判断队列是否为空
int SequeueIsEmpty(sequeue *sq)
{
    return sq->front == sq->rear ? 1 : 0;
}
//入队
void SequeueInput(sequeue *sq, DataType value)
{
    if(SequeueIsFull(sq))
    {
        printf("队列为满");
        return;
    }
    //将数据保存在rear对应的数组位置上
    sq->data[sq->rear] = value;
    //rear保存下一个元素的下标
    sq->rear = (sq->rear + 1) % N;
    return;
}
//出队
DataType SequeueOutput(sequeue *sq)
{
    if(SequeueIsEmpty(sq))
    {
        printf("队列为空，出队失败！\n");
        return (DataType)-1;
    }
    //定义临时变量保存要出队的数据
    DataType value = sq->data[sq->front];
    //front后移保存下一个要出队的数据的下标
    sq->front = (sq->front + 1) % N;
    return value;
}

1.3.3 main.c

#include "sequeue.h"
int main(int argc, char const *argv[])
{
    sequeue *sq = SequeueCreate();
    int i;
    for(i =0 ; i < 10;i++)
    {
        SequeueInput(sq,i + 1);
    }
    while(!SequeueIsEmpty(sq))
    {
        printf("出队:%d\n",SequeueOutput(sq));
    }
    return 0;
}

二、树和二叉树

2.1 概念

如果数据和数据之间满足一对多的关系，将其逻辑结构称之为树
最上层的第一个数据称之为根节点
如果一个结点有直接后继，将这些后继称之为子节点或子树，这个结点称之为这些子节点的父节点

度数：
一个结点的子树的个数称为该结点的度数
一颗树的度数是指该树中结点最大度数
边数:
一个结点系列，k1…ki 满足ki是ki+1的父节点，就称为一条从k1到ki的路径，路径的长度为i-1，即路径的边数
层数：
结点的层数等于父节点的层数加一，根节点的层数为1，树种结点层数的最大值称为该树的高度或者深度。
终端节点（叶子结点）:
度数为零的节点称为树叶或终端节点，度数不为零的节点称为分支节 点，除根节点外的分支节点称为内部节点
在这里插入图片描述

树的逻辑结构：
树种任何结点都可以有多个或者0个直接后继结点（子节点）
但是至多只能有一个直接前驱（父节点），根节点没有前驱结点
叶子饥饿点没有后继结点。

2.2 二叉树

如果树种的每一个结点最多有两个，那么将这个树称为二叉树。
二叉树与普通树不同，二叉树严格区分左孩子和右孩子，即使只有一个子节点也要区分左右

满二叉树 ：深度为k（k≥1）时有2^k－1个节点的二叉树。
完全二叉树 ：只有最下面两层有度数小于2的节点，且最下面一层的
叶节点集中在最左边的若干位置上。

2.2.1 二叉树的性质

性质1：在二叉树的第i层至多有2^(i -1)个结点。
性质2：深度为K的二叉树最多有2^k - 1个结点。
性质3：对任何一个二叉树，如果其终端结点数为n，度为2的结点数为m，则：
n = m+1；
性质4：具有n个结点的完全二叉树，其深度为（log2n）＋1或『log2(n+1)。
性质5：
如果对1棵有n个饥饿点的二叉树的饥饿点按层序编号，对任何一个结点i
（1）如果i= 1，则结点i是二叉树的根，无双亲，如果，如果i > 1,则其双亲结点为 i/2 。
（2）如果2i > n,则结点无左孩子，否则，其左孩子为2i。
（3）如果2i+ 1 > n,则结点无右孩子，否则，其右孩子为2i+1.

2.2.2 二叉树的存储

完全二叉树的结点编号方法是从上到下，从左往右，根节点为1号结点
设完全二叉树的节点数为n，某结点编号为I
2i <=n,有左孩子，其编号为2i,否则没有左孩子，本身是叶子结点
2i+1 <=n,有右孩子，其编号为2i + 1,否则没有右孩子

2.3二叉树的存储方式

2.3.1 二叉树的顺序存储

因为无法保存当前二叉树是一个满二叉树或者完全二叉树，所以，顺序存储时，需要将不存在的结点预留位置，这样做就会浪费空间，所以一般不使用顺序存储

在这里插入图片描述

2.3.2 二叉树的链式存储

二叉树使用链式存储时，每一个结点需要定义一个结构体，里面至少有三个成员，分别是一个数据域和两个指针域组成，数据域保存数据，指针域分别保存左右子树的地址。
在这里插入图片描述

typedef int DataType;
typedef struct node   //定义二叉树的结点结构体
{
  DataType data;
  struct node *left;    //指向左孩子的指针
  struct node *right;    //指向右孩子的指针
}bitree_t;

2.4 二叉树的遍历

2.4.1 二叉树的遍历：

先序遍历:先访问树根，再访问左子树，最后访问右子树 （根左右）
中序遍历：先访问左子树，再访问树根，最后访问右子树（左根右）
后序遍历:先访问左子树，再访问右子树，最后访问树根（左右根）
在这里插入图片描述

反推：中序必须有，先序或者后序有一个就可以

在这里插入图片描述

在这里插入图片描述

2.4.2 代码

#ifndef _TREE_H_
#define _TREE_H_
#include <stdio.h>
#include <stdlib.h>


typedef int DataType;
typedef struct node   //定义二叉树的结点结构体
{
  DataType data;
  struct node *left;    //指向左孩子的指针
  struct node *right;    //指向右孩子的指针
}bitree_t;
//创建一棵二叉树
bitree_t *CreateTree(DataType *a,int length);
//先序遍历
void PreOrder(bitree_t *root);
//中序遍历
void MidOrder(bitree_t *root);
//后序遍历
void PostOrder(bitree_t *root);
#endif

#include "tree.h"
//创建一棵二叉树
bitree_t *CreateTree(DataType *a,int length)
{
    bitree_t *array[11] ={0};
    int i;
    for(i = 0; i < length;i++)
    {
        array[i] = (bitree_t *)malloc(sizeof(bitree_t));
        if(NULL == array[i])
        {
            return NULL;
        }
        array[i]->data = a[i];
        array[i]->left = NULL;
        array[i]->right = NULL;
    }
    for(i = 0 ; i < length /2;i++)
    {
        array[i]->left = array[2*i + 1];
        array[i]->right = array[2*i + 2];
    }
    return array[0];
}
//先序遍历
void PreOrder(bitree_t *root)
{
    if(NULL == root)
    {
        return;
    }
    printf("%d ",root->data);
    PreOrder(root->left);
    PreOrder(root->right);
}
//中序遍历
void MidOrder(bitree_t *root)
{
    if(NULL == root)
    {
        return;
    }
    MidOrder(root->left);
    printf("%d ",root->data);
    MidOrder(root->right);
}
//后序遍历
void PostOrder(bitree_t *root)
{
    if(NULL == root)
    {
        return;
    }
    PostOrder(root->left);
    PostOrder(root->right);
    printf("%d ",root->data);
}

#include "tree.h"
int main(int argc, char const *argv[])
{
    DataType array[10] ={1,2,3,4,5,6,7,8,9,10};
    bitree_t *root1 = CreateTree(array,sizeof(array)/sizeof(array[0]));
    PreOrder(root1);
    putchar(10);
    MidOrder(root1);
    putchar(10);
    PostOrder(root1);
    putchar(10);
    return 0;
}

2.5 二叉搜索树

定义：二叉查找树，又被称为二叉搜索树，其特点，左孩子比父节点小，右孩子比父节点大。

//二叉搜索树
bitree_t* CreateBSTree(bitree_t *root,DataType num)
{
    if(NULL == root)
    {
        root = (bitree_t *)malloc(sizeof(bitree_t) * 1);
        if(NULL == root)
        {
            return NULL;
        }
        root->data = num;
        root->left = NULL;
        root->right = NULL;
    }
    else
    {
        if(root->data > num)
        {
            root->left = CreateBSTree(root->left,num);
        }
        else
        {
            root->right = CreateBSTree(root->right,num);
        }
    }
    return root;
}
周末不下雨
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实验——队列子系统
07-31
设计一个字符型的链队列；编写队列的进队、出队、读队头元素、显示队列中全部元素程序；设计一个选择式菜单，以菜单方式选择队列的各种基本操作。
数据结构——队列 求队列长度 C语言
03-16
输入若干个整数, 以0结束, 利用入队的操作生成一个循环队列, 求该队列的长度。
数据结构-栈、队列、数组、链表、树
m0_66570838的博客
03-16 303
本文主要介绍了数据结构中的栈、队列、数组、链表、树。
Linux下的流量控制（TC）和服务质量（QoS）
weixin_44475356的博客
08-22 3316
Linux下的流量控制（TC）和服务质量（QoS）的学习过程。
【栈、队列与二叉树】
m0_70964767的博客
08-06 1147
只能允许在容器的一端(称为栈顶端指标—— top) 进行加入数据(push)和输出数据(pop) 的运算。（5）对完全二叉树，若从上至下、从左至右编号，则编号为i的结点，其左孩子编号必为2i，其右孩子编号必为2i+1;（3）平衡二叉树(AVL树) :当且仅当任何节点的两棵子树的高度差不大于1的二叉树。（1）完全二叉树:对于一颗二叉树，假设其深度为d(d>1)，除了第d层外，其它各。（1）在二叉树的第i层上至多有2^(i-1)个节点(i>0)的原理简称，允许插入的一端为队尾，允许删除的一端为队头。......
【数据结构】二叉树&&优先级队列——堆
大三小白C++进阶之路
11-26 2053
二叉树的介绍及堆的实现与应用
二叉树与队列（队列实现：完全二叉树的判断以及层序遍历）
qq_52777887的博客
03-22 2522
队列与二叉树不可分割的关系！
数据结构入门——队列的实现.rar
04-02
队列是一种先进先出的数据结构：即插入在表的一端（队尾）进行，删除在表的另一端（队头）进行 与线性表相似，队列也有顺序储存和链式储存两种储存方法；实现方法和代码在此文档中，详细说明见本人博客
图解数据结构（使用Python）——队列
12-20
队列是一种抽象数据类型，具有先进先出的原则。 特性： 与堆栈（只有一个top指针）不同的是，队列有head和rear两个指针，分别指向队列的头和尾 有加入和删除两种基本操作，且在rear指针处加入元素，在head指针处删除...
数据结构课设——队列程序.pdf
10-06
数据结构课设——队列程序.pdf
树、图、队列知识总结
MrWilliamVs的专栏
10-04 221
队列 队列、堆、栈，都是运算受限的线性表。。 线性表 ， 先进先出、后进后出， 一端插入、一端删除。（FIFO） 顺序队列，链式队列，循环队列。。 优先队列： 找出键值最大（优先级最高）的元素，取出该元素，动态维护。 （总是处理优先级最高的任务。。） （只需要做的操作， 删除优先级最高的任务，插入任务。。） 树 树的基本操作：构建树、 树的遍历、插入某节点、查找某节点、删除某节点。 二叉树。。（最常用的树结构） 1.理想平衡二叉树，（常用！！！—） （堆结构，本质是完全二叉树，叶子节点的位置有规律，适合排序
【数据结构】树
翼遥君的博客
12-24 3324
1、树的定义     树（Tree）是n个结点（元素的有限集合）。当n=0时，称这棵树为空树。 在非树T中： （1）有且只有一个特殊的结点称为树的根结点（root），根结点没有前驱结点。 （2）当n>1时，除了根结点之外的其余的结点又被分成m个互不相交的子集。每个 子集本身又是一棵树，这些树称为根结点的子树。 2、相关的术语 （1）结点的度、树的度 结点的度：结点所拥有所有
数据结构 -- 栈、队列、树
Sco_jing的博客
08-15 1454
文章目录线性表栈队列二叉树 线性表 线性表是一种可以在任意位置进行插入和删除数据元素操作的、由n(n>=0)个相同类型数据元素a0、a1、a2，…，a(n-1)组成的线性结构。 线性表是一种最简单的线性结构。 特点：除第一个和最后一个元素以外，每个数据元素只有一个前驱数据元素和一个后继数据元素。 栈 堆栈和队列都是特殊的线性表。 线性表、堆栈和队列三者的数据元素之间的逻辑关系完全相同，差别是：线性表的插入和删除操作不受限制，而堆栈只能在栈顶插入和删除，队列只能在队尾插入，在队头删除。 堆栈和队列
【数据结构】队列(顺序队列、循环队列、链队列）
热门推荐
Jacky_Feng的博客
09-15 2万+
文章目录 前言 一、队列的定义 二、队列的顺序存储结构 1.顺序队列的定义 2.循环队列定义 3.循环队列的基本操作 三、队列的链式存储结构 1.链队列的定义 2.链队列的基本操作 前言 队列也是一种线性表，其特殊性在于队列的基本操作是线性表的子集。队列按“先进先出”的规则进行操作，故称其为操作受限的线性表。 一、队列的定义 队列（queue）是只允许在一端进行插入操作，在另一端进行删除操作的线性表，简称“队”。 队列是一种先进先出（First In First Out）的
数据结构-优先队列和树
草帽小子的博客
09-18 267
8、优先队列和树 优先队列 普通队列：先进先出，后进后出 优先队列：出队顺序和入队顺序无关，和优先级有关 为什么使用优先队列 动态选择优先级最高的执行任务 关键词：动态 优先队列实现接口 优先队列的实现方式： 普通顺序结构：数组 顺序线性结构：已经排序好的 堆：最大堆或者最小堆 优先队列的实现(基于堆) public class PriorityQueue <E extends Comparable<E>> implements Queue<E> {
数据结构——堆、栈、队列、树、图
hailoneko的博客
07-22 5717
数据结构中的堆栈： 堆可以看成一棵按顺序排列的完全二叉树，根节点可以为大于等于任何子节点（也可以小于等于任意子节点，看具体的排序方法），在存取时没有任何限制，可以随意的访问某一个子节点。 栈或者称为堆栈（stack），可以看成是一些堆起来的盘子，桶状线性数据结构。但是栈是受限制的线性数据结构，只允许先进后出，并且只能在栈顶进行插入删除操作。 内存区的堆栈： 首先了解下内存区：堆区存放程序员...
队列和树
weixin_40107913的博客
02-27 220
什么是队列 具有一定操作约束的线性表 只能在一端删除，另一端插入——先进先出表 数据结构 链式存储
树和队列
chuju3227的博客
07-25 356
* 什么是树？ * 树是n个节点有序集合，有且仅有一个根节点 * n>1时，其余节点可以分为m个互不干扰的有限集合 每一个集合又是一个树，并且是根节点的子树 * * 什么是二叉树？ * 二叉树是树一种特殊形式，每一个节点最多有两个孩子节点， * 二叉树包含完全二叉树和满二叉树...
数据结构（树、队列、栈）
seaeress的博客
09-17 431
树结构 结点的度（Degree）：结点拥有的子树数目 树的度：树中各结点度的最大值 叶子结点（Leaf）：度为0的结点 孩子结点（Child）：一个结点的子树的根结点 双亲结点（Parent）：与孩子结点对应 兄弟结点（Sibling）：一个双亲结点的孩子结点之间为兄弟结点 结点的层次（Level）：从根结点开始，根结点为第一层，根结点的孩子结点为第二层，以此类推。 树的深度（Depth）：树中结...
数据结构课设——航空航天订票系统
最新发布
12-10
这个航空航天订票系统的数据结构包括航班信息、乘客信息、预定队列等。其中航班信息包括航班编号、起点、终点、出发时间、到达时间、机型、剩余座位数等；乘客信息包括姓名、身份证号、订票等级等。预定队列则是用来存储没有订到座位的乘客信息，以便后续安排。 该系统的设计思路是先通过管理员添加航班信息，然后乘客可以通过查询所有航班或者根据起点终点搜索航班来选择自己想要的航班。订票时，系统会检查该航班是否还有剩余座位，若有则订票成功，否则会推荐其他航班或者进入预定队列。退票时，系统会将该乘客的座位释放，并更新航班的剩余座位数。管理员可以添加或删除航班信息。 该系统的特点是实现了航班信息的管理、乘客订票、退票等功能，同时还考虑了预定队列的情况，能够更好地满足用户需求。不足之处可能在于界面设计和用户体验方面还有待改进。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值