队列及其c语言实现

最新推荐文章于 2024-02-13 19:16:34 发布
最新推荐文章于 2024-02-13 19:16:34 发布
阅读量2.2w 收藏 142
点赞数 27
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lym152898/article/details/52202606
版权

队列的基本概念

队列 (Queue) :也是运算受限的线性表。是一种先进先出 (First In First Out ,简称 FIFO) 的线性表。只允许在表的一端进行插入,而在另一端进行删除。
队首 (front) :允许进行删除的一端称为队首。
队尾 (rear) :允许进行插入的一端称为队尾。

队列中没有元素时称为空队列。在空队列中依次加入元素 a 1 , a 2 , …, a n 之后, a 1 是队首元素, a n 是队尾元素。显然退出队列的次序也只能是 a 1 , a 2 , …, a n ,即队列的修改是依先进先出的原则进行的,如图 3-5 所示。

这里写图片描述

基本操作

  1. 创建新队列
  2. 判空
  3. 进队
  4. 出队
  5. 清空队
  6. 获得队头元素
  7. 遍历队
  8. 销毁队
  9. 队长

顺序队列

利用一组连续的存储单元 ( 一维数组 ) 依次存放从队首到队尾的各个元素,称为顺序队列。对于队列,和顺序栈相类似,也有动态和静态之分。这里介绍静态顺序队列.其类型定义如
下:

typedef int datatype;
#define MAX_QUEUE_SIZE 100
typedef struct queue
{ 
    datatype queue_array[MAX_QUEUE_SIZE];
    int front;
    int rear;
}sp_queue;

设立一个队首指针 front ,一个队尾指针rear ,分别指向队首和队尾元素。
◆ 初始化: front=rear =0。
◆ 入队:将新元素插入 rear 所指的位置,然后rear 加 1 。
◆ 出队:删去 front 所指的元素,然后加 1 并返回被删元素。
◆ 队列为空: front=rear 。
◆ 队满: rear = MAX_QUEUE_SIZE - 1 或front=rear 。

在非空队列里,队首指针始终指向队头元素,而队尾指针始终指向队尾元素的下一位置。顺序队列中存在“假溢出”现象。因为在入队和出队操作中,头、尾指针只增加不减小,致使被删除元素的空间永远无法重新利用。因此,尽管队列中实际元素个数可能远远小于数组大小,但可能由于尾指针巳超出向量空间的上界而不能做入队操作。该现象称为假溢出。如图 3-6 所示是数组大小为 5 的顺序队列中队首、队尾指针和队列中元素的变化情况。
假溢出现象

代码实现

/* 顺序队列接口定义头文件*/
#define true 1
#define false 0


/* 队的最大长度 */
#define MAX_QUEUE_SIZE 100
/* 队列的数据类型 */
typedef int datatype;

/* 静态链的数据结构 */
typedef struct queue{
    datatype sp_queue_array[MAX_QUEUE_SIZE];
    /* 队头 */
    int front;
    /* 队尾 */
    int rear;
}sp_queue;


/* 静态顺序链的接口定义 */


/* 静态链的初始化 */
sp_queue queue_init();

/* 判断队列是否为空,若为空
 * 返回true
 * 否则返回false
*/
int queue_empty(sp_queue q);


/* 插入元素e为队q的队尾新元素 
 * 插入成功返回true
 * 队满返回false
*/
int queue_en(sp_queue *q, datatype e);


/* 队头元素出队
 * 用e返回出队元素,并返回true
 * 若队空返回false
*/
int queue_de(sp_queue *q, datatype *e);

/* 清空队 */
void queue_clear(sp_queue *q);


/* 获得队头元素
 * 队列非空,用e返回队头元素,并返回true
 * 否则返回false
*/
int get_front(sp_queue, datatype *e );


/* 获得队长 */
int queue_len(sp_queue q);

/* 遍历队 */
void queue_traverse(sp_queue q, void(*visit)(sp_queue q));


void visit(sp_queue s);


/* 接口实现文件 */
#include<stdio.h>
#include<stdlib.h>
#include"sp_queue.h"


sp_queue queue_init()
{
    sp_queue q;
    q.front = q.rear = 0;
    return q;
}



int queue_empty(sp_queue q)
{
    return q.front == q.rear;
}


int queue_en(sp_queue *q, datatype e)
{
    /* 队满 */
    if (q -> rear == MAX_QUEUE_SIZE)
        return false;

    /* 入队 */
    q -> sp_queue_array[q -> rear] = e;
    printf("q.sp_queue_array[%d]=%d\n", q -> rear, e);
    q -> rear += 1;
    return true;

}


int queue_de(sp_queue *q, datatype *e)
{
    /* 队空 */
    if(queue_empty(*q))
        return false;

    /* 出队 */
    q -> rear -= 1;
    *e = q -> sp_queue_array[q -> rear];
    return true;
}


void queue_clear(sp_queue *q)
{
    q -> front = q -> rear = 0;
}


int get_front(sp_queue q, datatype *e)
{
    /* 队空 */
    if(q.front == q.rear)
        return false;

    /* 获取队头元素 */
    *e = q.sp_queue_array[q.front];
    return true;
}


int queue_len(sp_queue q)
{
    return (q.rear - q.front);
}


void queue_traverse(sp_queue q, void (*visit)(sp_queue q))
{
    visit(q);
}

void visit(sp_queue q)
{
    /* 队空 */
    if (q.front == q.rear)
        printf("队列为空\n");

    int temp = q.front;
    while(temp != q.rear)
    {
        printf("%d ",q.sp_queue_array[temp]);
        temp += 1;
    }
    printf("\n");
}



int main()
{
    sp_queue q = queue_init();
    queue_en(&q, 1);
    queue_en(&q, 2);
    printf("length=%d\n", queue_len(q));
    queue_en(&q, 3);
    printf("length=%d\n", queue_len(q));
    queue_en(&q, 4);
    printf("length=%d\n", queue_len(q));
    queue_en(&q, 5);
    printf("length=%d\n", queue_len(q));
    queue_en(&q, 6);
    printf("length=%d\n", queue_len(q));
    queue_traverse(q,visit);
    datatype *e = (datatype *)malloc(sizeof(*e));
    queue_de(&q,e);
    printf("queue_de(),e=%d length=%d\n", *e, queue_len(q));
    queue_traverse(q, visit);
    queue_clear(&q);
    queue_traverse(q, visit);
    printf("length:%d\n", queue_len(q));
}

注意:结构体变量作为函数的参数和其他普通变量一样,值只会在函数体内被修改,想要通过函数更改结构体的值,可以通过结构体指针作为函数的参数实现.

队列的链式表示和实现

队列的链式存储结构简称为链队列,它是限制仅在表头进行删除操作和表尾进行插入操作的单链表。需要两类不同的结点:数据元素结点,队列的队
首指针和队尾指针的结点,如图 3-8 所示。
这里写图片描述
数据元素结点类型定义:

typedef struct q_node{
    datatype data;
    struct q_node *next;
}q_node;

指针结点类型:

typedef struct {
    q_node *front;
    q_node *rear;   
}link_queue;

链队运算及指针变化

链队的操作实际上是单链表的操作,只不过是删除
在表头进行,插入在表尾进行。插入、删除时分别修改
不同的指针。链队运算及指针变化如图 3-9 所示。

这里写图片描述

代码实现

/* 链式栈接口的定义头文件 */
#define true 1
#define false 0


/* 队列的数据类型 */
typedef int datatype;

/* 静态链的数据结构 */
typedef struct q_node{
    datatype data;
    struct q_node *next;
}q_node,*link_node;

typedef struct l_queue{
    /* 队头指针 */
    q_node *front;
    /* 队尾指针 */
    q_node *rear;
}*link_queue;


/* 静态顺序链的接口定义 */


/* 静态链的初始化 */
link_queue queue_init();

/* 判断队列是否为空,若为空
 * 返回true
 * 否则返回false
*/
int queue_empty(link_queue q);

/* 插入元素e为队q的队尾新元素 
 * 插入成功返回true
 * 队满返回false
*/
int queue_en(link_queue q, datatype e);


/* 队头元素出队
 * 用e返回出队元素,并返回true
 * 若队空返回false
*/
int queue_de(link_queue q, datatype *e);

/* 清空队 */
void queue_clear(link_queue q);

/* 销毁队 */
void queue_destroy(link_queue q);

/* 获得队头元素
 * 队列非空,用e返回队头元素,并返回true
 * 否则返回false
*/
int get_front(link_queue q, datatype *e );


/* 获得队长 */
int queue_len(link_queue q);

/* 遍历队 */
void queue_traverse(link_queue q, void(*visit)(link_queue q));


void visit(link_queue q);



/* 接口的实现文件 */
#include<stdio.h>
#include<stdlib.h>
#include"lp_queue.h"



link_queue queue_init()
{
    /* 新建头结点 */
    link_node new_node = (link_node)malloc(sizeof(q_node));
    new_node -> next = NULL;
    /* 指针结点 */
    link_queue q = (link_queue)malloc(sizeof(*q));
    q -> front = q -> rear = new_node;
    return q;
}


int queue_empty(link_queue q)
{
    return q -> front == q -> rear;
}


int queue_en(link_queue q, datatype e)
{
    /* 新建数据结点 */
    link_node new_node = (link_node)malloc(sizeof(q_node));
    /* 内存分配失败 */
    if(!new_node)
        return false;
    new_node -> data = e;
    q -> rear -> next = new_node;
    q -> rear = new_node;
    return true;
}

int queue_de(link_queue q, datatype *e)
{
    /* 队列为空 */
    if (q -> front == q -> rear)
        return false;

    *e = q -> front -> next -> data;
    link_node temp = q -> front -> next;
    q -> front -> next = temp -> next;
    /* 防止丢失尾指针 */
    if (temp == q.rear -> next)
        q -> rear = q -> front; 
    free(temp);
    temp = NULL;
    return true;
}

void queue_clear(link_queue q)
{
    /* 头结点 */
    link_node head = q -> front -> next;
    head -> next = NULL;
    q -> front = q -> rear = head;
    /* 第一个结点 */
    link_node temp = head -> next;
    while(temp)
    {
        link_node p = temp;
        temp = p -> next;
        free(p);
        p = NULL;
    }
}


void queue_destroy(link_queue q)
{
    queue_clear(q);
    free(q);
    q = NULL;
}


int get_front(link_queue q, datatype *e)
{
    /* 队为空 */
    if (q -> front == q -> rear)
        return false;

    *e = q -> front -> next -> data;
    link_node temp = q -> front -> next;
    q -> front -> next = temp -> next;
    free(temp);
    temp = NULL;
    return true;
}


int queue_len(link_queue q)
{
    /* 头结点 */
    link_node p = q -> front -> next;
    /* 计数器 */
    int count = 0;
    while(p)
    {
        count += 1;
        p = p -> next;
    }
    return count;
}


void queue_traverse(link_queue q, void(*visit)(link_queue q))
{
    visit(q);
}

void visit(link_queue q)
{
    /* 头结点 */
    link_node p = q -> front -> next;
    if(!p)
    {
        printf("队列为空");
    }
    while(p)
    {
        printf("%d ", p -> data);
        p = p -> next;
    }
    printf("\n");
}

int main()
{
    link_queue q = queue_init();
    queue_en(q, 1);
    queue_en(q, 2);
    printf("length=%d\n", queue_len(q));
    queue_en(q, 3);
    printf("length=%d\n", queue_len(q));
    queue_en(q, 4);
    printf("length=%d\n", queue_len(q));
    queue_en(q, 5);
    printf("length=%d\n", queue_len(q));
    queue_en(q, 6);
    printf("length=%d\n", queue_len(q));
    queue_traverse(q,visit);
    datatype *e = (datatype *)malloc(sizeof(*e));
    queue_de(q,e);
    printf("queue_de(),e=%d length=%d\n", *e, queue_len(q));
    queue_traverse(q, visit);
    queue_clear(q);
    queue_traverse(q, visit);
    printf("length:%d\n", queue_len(q));
}

执行结果:
这里写图片描述

lym152898
关注
  • 27
    点赞
  • 踩
  • 142
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
链式队列的基本运算
09-03
本程序共设计了单链表上多项式相加需要的的6个基本操作运算，分别是链式队列的入队，出队，遍历，长度，取队头，以及销毁队列操作。附带实验报告。
【数据结构】C语言队列(详解)
weixin_65186652的博客
08-31 5416
C语言实现队列,详细解读
C语言实现队列
热门推荐
m0_60447315的博客
03-26 1万+
📋 个人简介 💖 作者简介：大家好，我是菀枯😜 🎉 支持我：点赞👍+收藏⭐️+留言📝 💬格言：不要在低谷沉沦自己，不要在高峰上放弃努力！☀️ 前言 前一段时间，我们试着用C语言实现了数据结构中的顺序表，单链表，双向循环链表，栈😃。今天我们再用C语言来实现另一种特殊的线性结构：队列 一. 什么是队列 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（head）进行删除操作，而在表的后端（tail）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除
【C语言】实现队列
最新发布
水墨不写bug
02-13 1531
C语言实现队列，手撕队列
C语言-队列
Discod_lim的博客
03-21 1357
队列的基本操作
C语言---队列(详解）---数据结构
weixin_57535054的博客
02-11 6806
队列所需要的头文件 先给类型重命名 意义前几篇有讲 队列要用到的两个结构体 第一个结构体里面有 1.存储数据的 a 2.指向下一个节点的指针 重命名为Queue（这里的名字需要记一下，等会需要分辨两个结构体，结构体两个的功能是不一样的） 第二个结构体里面有 1.指向头的头指针 2.指向尾的尾指针 重命名尾Qnene 队列实现的函数功能有： 1.初始化队列 2.队尾入数据 3.队头出数据 4.获取队列的有效元素个数 5.判断队列是否为空 6.获取队列头部数据7.获...
c语言实现队列
m0_61438674的博客
10-05 5249
c语言实现队列
C语言实现简易扑克牌游戏
01-20
出牌时，如果某人打出的牌与桌上某张牌的牌面相同，即可将两张相同的牌及其中间所夹的牌全部取走，并依次放到自己手中牌的末尾。当任意一人手中的牌全部出完时，游戏结束，对手获胜。 以下是代码的实现： #define _...
C语言实现计算机网络技术.zip
07-05
queue.c/h：队列数据结构的封装文件并实现了队列的一系列操作的函数 task.c/h：上传和下载任务的函数分装文件，定义了任务、连接等结构，实现了对上传和下载的控制操作函数 timer.c/h：计算时间辅助文件，实现了计算...
C语言实现纸牌游戏之小猫钓鱼算法
12-25
本文实例为大家分享了C语言实现小猫钓鱼算法的具体代码，供大家参考，具体内容如下 星期天小哼和小哈约在一起玩桌游，他们正在玩一个非常古怪的扑克游戏——“小猫钓鱼”。游戏的规则是这样的：将一副扑克牌平均分成...
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
数据结构——队列的C语言代码实现
AZ10000000的博客
05-05 3886
系列文章目录 数据结构——顺序表的C语言代码实现 数据结构——八种链表的C语言代码实现 数据结构——栈的C语言代码实现 文章目录系列文章目录前言一、基础知识队列的概念（queue）二、代码实现1.queue.h2.queue.c3.test.c总结 前言 主要实现链式队列。 提示：以下是本篇文章正文内容，下面案例可供参考 一、基础知识 队列的概念（queue） 援引百科： 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，
队列（C语言实现）
m0_59311392的博客
09-18 1635
1.1 定义：队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out)入队列：进行插入操作的一端称为队尾出队列：进行删除操作的一端称为队头int front;int rear;}QueNode;int size;}Queue双端队列是指允许两端都可以进行入队和出队操作的队列。其元素的逻辑结构仍是线性结构。将队列的两端称为前端和后端，两端都可以入队和出队。
队列的实现（C语言）
qq_931027577
08-07 1万+
队列的定义队列的顺序存储-->循环队列方案1：牺牲一个单元来区分队空和队满方案2：增设表示元素个数的变量（不牺牲存储单元）方案3：增设tag数据成员区分队空队满（不牺牲存储单元）链式队列的实现带头结点的链式队列不带头结点的链式队列 队列的定义 队列（Queue） 是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。 队列操作的特性：先进先出（Frist In First Out） 队列的顺序存储–>循环队列 方案1：牺牲一个单元来区分队空和队满 实现： // .
队列（C语言）
weixin_61196797的博客
09-23 4202
本篇进行队列的学习。使用C语言实现。
数据结构——队列（C语言实现）
sinzz的博客
04-16 2707
首先，我们需要定义的是链式结构的队列，即单链表为底层实现的。所以需要定义单链表结构来存储数据。然后，定义队列，队列里需要定义两个指向单链表的指针，一个是指向单链表头结点的指针，另一个则用来保存尾结点地址的指针。最后，还需定义一个记录当前队列元素个数的变量，用于遍历队列和判空。int size;} Queue;
队列c语言实现
btzxlin的博客
11-18 847
队列是一种数据结构，这种结构的特点是先进先出，后进后出。有点类似于数组只能尾插和头删。不过我们不用数组实现队列，因为数组的头删需要挪动后面所有的数据，成本过高。我们采用单链表来实现队列.
C语言 队列（循环队列和链队初始化进出队等基本操作）
m0_73070900的博客
04-23 1万+
循环队列、链队的初始化、进队和出队等基本操作-----
[数据结构 -- C语言] 队列(Queue)
Ljy_cx_21_4_3的博客
05-18 1869
链表实现队列，代码+详解。
哈夫曼编码c语言实现
09-11
哈夫曼编码的C语言实现可以通过以下步骤来完成： 1. 首先，需要构建哈夫曼树。哈夫曼树是一种特殊的二叉树，其中每个叶子节点对应一个字符，而每个非叶子节点对应一个权值。构建哈夫曼树的过程包括以下几个步骤： - 创建一个优先队列，并将每个字符及其对应的权值作为节点插入队列中。 - 反复执行以下操作，直到队列中只剩一个节点： - 从队列中取出权值最小的两个节点，将它们作为左右子节点创建一个新的节点，并将该节点插入队列中。 - 最后剩下的那个节点即为哈夫曼树的根节点。 2. 构建哈夫曼编码表。哈夫曼编码是一种前缀编码，通过遍历哈夫曼树，从根节点到每个叶子节点的路径上的边的取值来表示每个字符的编码。构建哈夫曼编码表的过程包括以下几个步骤： - 从根节点开始遍历哈夫曼树，当遇到叶子节点时，记录下从根节点到该叶子节点路径上的边的取值，并将该取值作为该叶子节点对应字符的编码。 3. 使用哈夫曼编码表对输入文本进行编码。遍历输入文本的每个字符，查找该字符在哈夫曼编码表中对应的编码，并将编码输出。 以上就是哈夫曼编码的C语言实现的基本步骤。你可以根据这些步骤来编写你自己的哈夫曼编码实现代码。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值