数据结构与算法----队列

最新推荐文章于 2022-04-16 20:53:45 发布
最新推荐文章于 2022-04-16 20:53:45 发布
阅读量228 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45932712/article/details/119449983
版权

1队列的基本概念
队列(Queue):也是运算受限的线性表。是一种先进先出(First In First Out，简称FIFO)的线性表。只允许在表的一端进行插入，而在另一端进行删除。
队首(front):允许进行删除的一端称为队首。队尾(rear) :允许进行插入的一端称为队尾。
例如∶排队购物。操作系统中的作业排队。先进入队列的成员总是先离开队列。
 

顺序队列的基本操作

/*----------------------------------------------------------------
设立一个队首指针front ，一个队尾指针rear ，分别指向队首和队尾元素。

 ◆ 初始化：front=rear=0。
 ◆ 队列为空：front=rear。
 ◆ 队满：rear=MaxSize。
 ◆ 入队：将新元素插入rear所指的位置，然后rear加1。
 ◆ 出队：删去front所指的元素，然后加1并返回被删元素。
 ◆ 取队首元素：返回fornt指向的元素值
 -----------------------------------------------------------------*/

#include <stdio.h>
#include <assert.h>
#include <Windows.h>

#define MaxSize 10  //队列的最大容量

typedef int DataType;  //队列中元素类型
typedef struct Queue
{
    DataType Queue[MaxSize];
    int fornt;   //队头指针
    int rear;    //队尾指针
}SeqQueue;

//队列初始化，将队列初始化为空队列
void InitQueue(SeqQueue *SQ)
{
    SQ->fornt = SQ->rear = 0;  //把对头和队尾指针同时置0
 }

//判断队列为空

int IsEmpty(SeqQueue* SQ)
{
    if (SQ->fornt == SQ->rear)
    {
        return 1;
    }
    return 0;
}

//判断队列是否为满

int IsFull(SeqQueue* SQ)
{
    if (SQ->rear == MaxSize) 
    {
        return 1;
    }
    return 0;
}

//入队,将元素data插入到队列SQ中

void EnterQueue(SeqQueue* SQ,DataType data)
{
    if (IsFull(SQ))
    {
        printf("队列已满\n");
        return 0;
    }
    SQ->Queue[SQ->rear] = data;  //在队尾插入元素data
    SQ->rear = SQ->rear + 1;     //队尾指针后移一位
}

//出队，将队列中队头的元素data出队，出队后队头指针front后移一位
int DeleteQueue(SeqQueue* SQ,DataType* data)
{
    if (IsEmpty(SQ))
    {
        printf("队列为空！\n");
        return 0;
    }
    *data = SQ->Queue[SQ->fornt];   //出队元素值
    SQ->fornt = (SQ->fornt)+1;      //队尾指针后移一位
    return 1;
}

//获取队首元素

int GetHead(SeqQueue* SQ,DataType* data)
{
    if (IsEmpty(SQ))
    {
        printf("队列为空!\n");
    }
    return *data = SQ->Queue[SQ->fornt];  
}

//清空队列

void ClearQueue(SeqQueue* SQ)
{
    SQ->fornt = SQ->rear = 0;
}

//打印队列中的与元素

void PrintQueue(SeqQueue* SQ)
{
    assert(SQ);    
    int i = SQ->fornt;
    while(i<SQ->rear)
    {
        printf("%-3d", SQ->Queue[i]);
        i++;
    }
    printf("\n");
}
int main()
{
    SeqQueue SQ;
    DataType data;
    //初始化队列
    InitQueue(&SQ);
    //入队
    EnterQueue(&SQ, 1);
    EnterQueue(&SQ, 2);
    EnterQueue(&SQ, 3);
    EnterQueue(&SQ, 4);
    EnterQueue(&SQ, 5);
    EnterQueue(&SQ, 6);
    EnterQueue(&SQ, 8);
    EnterQueue(&SQ, 10);
    EnterQueue(&SQ, 12);
    EnterQueue(&SQ, 15);
    EnterQueue(&SQ, 16);

    //打印队列中的元素
    printf("队列中的元素为：");
    PrintQueue(&SQ);
    printf("\n");
    //出队
    DeleteQueue(&SQ, &data);
    printf("出队元素为：%d\n", data);
    printf("\n");
    DeleteQueue(&SQ, &data);
    printf("出队元素为：%d\n", data);
    printf("\n");
    printf("队列中的元素为：");
    PrintQueue(&SQ);
    printf("\n");
    //获取队首元素
    data = GetHead(&SQ, &data);
    printf("队首元素为：%d\n", data);
    printf("#元素16入队#\n");
    //元素16入队
    EnterQueue(&SQ, 16);
    printf("队列中的元素为：");
    PrintQueue(&SQ);
    printf("\n");
    system("pause");
    return 0;
}

循环队列的基本操作

/*----------------------------------------------------------------
设立一个队首指针front ，一个队尾指针rear ，分别指向队首和队尾元素。

◆ 初始化：front=rear=0。
◆ 队列为空：front=rear。
◆ 队满：（rear + 1) % MaxSize == fornt
◆ 入队：将新元素插入rear所指的位置，然后rear加1。
◆ 出队：删去front所指的元素，然后加1并返回被删元素。
◆ 取队首元素：返回fornt指向的元素值
-----------------------------------------------------------------*/

#include<stdio.h>
#include<Windows.h>
#include<assert.h>

#define MaxSize 10
typedef int DataType;
typedef struct SeqQueue
{
    DataType Queue[MaxSize];
    int fornt;
    int rear;
}SeqCirQueue;

//队列初始化

void InitSeqCirQueue(SeqCirQueue* SCQ)
{
    SCQ->fornt = SCQ->rear = 0;
}

//判断队列是否为空
int IsEmpty(SeqCirQueue* SCQ)
{
    if (SCQ->fornt == SCQ->rear)
    {
        return 1;
    }
    return 0;
}

//判断队列是否为满
int IsFull(SeqCirQueue* SCQ)
{
    //尾指针+1追上队头指针，标志队列已经满了
    if ((SCQ->rear + 1) % MaxSize == SCQ->fornt)
    {
        return 1;
    }
    return 0;
}

//入队操作
int EnterSeqCirQueue(SeqCirQueue* SCQ, DataType data)
{
    if (IsFull(SCQ))
    {
        printf("队列已满，不能入队！\n");
        return 0;
    }
    SCQ->Queue[SCQ->rear] = data;
    SCQ->rear = (SCQ->rear + 1) % MaxSize;   //重新设置队尾指针
}


//出队操作
int DeleteSeqCirQueue(SeqCirQueue* SCQ,DataType* data)
{
    if (IsEmpty(SCQ))
    {
        printf("队列为空！\n");
        return 0;
    }
    *data = SCQ->Queue[SCQ->fornt];
    SCQ->fornt = (SCQ->fornt + 1) % MaxSize;  //重新设置队头指针
}

//取队首元素
int GetHead(SeqCirQueue* SCQ,DataType* data)
{
    if (IsEmpty(SCQ))
    {
        printf("队列为空！\n");
        return 0;
    }
    *data = SCQ->Queue[SCQ->fornt];
    return *data;
}

//清空队列
void ClearSeqCirQueue(SeqCirQueue* SCQ)
{
    SCQ->fornt = SCQ->rear = 0;
}

//打印队列元素
void PrintSeqCirQueue(SeqCirQueue* SCQ)
{
    assert(SCQ);   //断言SCQ不为空
    int i = SCQ->fornt;
    if (SCQ->fornt < SCQ->rear)
    {
        for (; i < SCQ->rear; i++)
        {
            printf("%-3d", SCQ->Queue[i]);
        }
    }
    else
    {
        for (i; i <SCQ->rear + MaxSize; i++)
        {
            printf("%-3d", SCQ->Queue[i]);
        }
    }
    printf("\n");
}

int main()
{
    SeqCirQueue SCQ;
    DataType data;
    //初始化队列
    InitSeqCirQueue(&SCQ);
    //入队
    EnterSeqCirQueue(&SCQ, 1);
    EnterSeqCirQueue(&SCQ, 2);
    EnterSeqCirQueue(&SCQ, 4);
    EnterSeqCirQueue(&SCQ, 6);
    EnterSeqCirQueue(&SCQ, 8);
    EnterSeqCirQueue(&SCQ, 9);
    EnterSeqCirQueue(&SCQ, 10);
    EnterSeqCirQueue(&SCQ, 12);
    EnterSeqCirQueue(&SCQ, 13);
    printf("队列中元素为：\n");
    //打印队列中元素
    PrintSeqCirQueue(&SCQ);
    EnterSeqCirQueue(&SCQ, 15);
    //出队
    DeleteSeqCirQueue(&SCQ, &data);
    printf("出队元素为：%d\n", data);
    printf("\n");
    printf("队列中元素为：\n");
    PrintSeqCirQueue(&SCQ);
    printf("15入队：\n");
    EnterSeqCirQueue(&SCQ, 15);
    printf("队列中元素为：\n");
    PrintSeqCirQueue(&SCQ);
    system("pause");
    return 0;
}

*链式队列的基本操作

#include <stdio.h>
#include <Windows.h>
#include <stdlib.h>
#include <assert.h>

typedef int DataType;
typedef struct Node
{
    DataType _data;
    struct Node* _next;
}LinkQueueNode;

typedef struct
{
    LinkQueueNode* front;
    LinkQueueNode* rear;
}LinkQueue;

//初始化队列
void InitLinkQueue(LinkQueue* LQ)
{
    //创建一个头结点
    LinkQueueNode* pHead = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
    assert(pHead);
    LQ->front = LQ->rear = pHead; //队头和队尾指向头结点
    LQ->front->_next = NULL;
}

//判断队列是否为空

int IsEmpty(LinkQueue* LQ)
{
    if (LQ->front->_next == NULL)
    {
        return 1;
    }
    return 0;
}

//入队操作

void EnterLinkQueue(LinkQueue* LQ, DataType data)
{
    //创建一个新结点
    LinkQueueNode* pNewNode = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
    assert(pNewNode);
    pNewNode->_data = data;  //将数据元素赋值给结点的数据域
    pNewNode->_next = NULL;  //将结点的指针域置空
    LQ->rear->_next = pNewNode;   //将原来队列的队尾指针指向新结点
    LQ->rear = pNewNode;      //将队尾指针指向新结点
}

//出队操作

void DeleteLinkQueue(LinkQueue* LQ,DataType* data)
{
    if (IsEmpty(LQ))
    {
        printf("队列为空！\n");
        return;
    }
    //pDel指向队头元素，由于队头指针front指向头结点，所以pDel指向头结点的下一个结点
    LinkQueueNode* pDel = LQ->front->_next;  
    *data = pDel->_data;   //将要出队的元素赋给data
    LQ->front->_next = pDel->_next;  //使指向头结点的指针指向pDel的下一个结点
    //如果队列中只有一个元素,将队列置空
    if (LQ->rear = pDel)   
    {
        LQ->rear = LQ->front;
    }
    free(pDel);   //释放pDel指向的空间
}

//取队头元素

int GetHead(LinkQueue* LQ, DataType* data)
{
    if (IsEmpty(LQ))
    {
        printf("队列为空!\n");
        return 0;
    }
    LinkQueueNode* pCur;
    pCur = LQ->front->_next;  //pCur指向队列的第一个元素，即头结点的下一个结点
    *data = pCur->_data;      //将队头元素值赋给data
    return *data;             //返回队头元素值
}

//清空队列

void ClearQueue(LinkQueue* LQ)
{
    while (LQ->front != NULL)
    {
        LQ->rear = LQ->front->_next;  //队尾指针指向队头指针的下一个结点
        free(LQ->front);              //释放队头指针指向的结点
        LQ->front = LQ->rear;         //队头指针指向队尾指针
    }
}

//打印队列中的元素

void PrintLinkQueue(LinkQueue* LQ)
{
    assert(LQ);
    LinkQueueNode * pCur;
    pCur = LQ->front->_next;
    while (pCur)
    {
        printf("%-3d", pCur->_data);
        pCur = pCur->_next;
    }
    printf("\n");
}
int main()
{
    LinkQueue LQ; 
    DataType data;
    //初始化队列
    InitLinkQueue(&LQ);
    //入队
    EnterLinkQueue(&LQ, 1); 
    EnterLinkQueue(&LQ, 2);
    EnterLinkQueue(&LQ, 3);
    EnterLinkQueue(&LQ, 4);
    EnterLinkQueue(&LQ, 5);
    EnterLinkQueue(&LQ, 6);
    EnterLinkQueue(&LQ, 7);
    EnterLinkQueue(&LQ, 8);
    printf("队列中的元素为：");
    //打印队列中元素
    PrintLinkQueue(&LQ);
    printf("\n");
    //取队头元素
    data = GetHead(&LQ, &data);
    printf("队头元素为：%d\n", data);
    printf("\n");
    //出队
    DeleteLinkQueue(&LQ, &data);
    printf("出队的元素为：%d\n", data);
    printf("\n");
    printf("队列中的元素为：");
    PrintLinkQueue(&LQ);
    printf("\n");
    data = GetHead(&LQ, &data);
    printf("队头元素为：%d\n", data);
    printf("\n");
    ClearQueue(&LQ);
    system("pause");
    return 0;
}

————————————————
版权声明：本文为CSDN博主「LiuBo_01」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/LiuBo_01/article/details/80412290

WUWWWQUE
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构——顺序队列的基本操作（C语言实现）
m0_46657980的博客
07-26 768
1、定义 #define QUEUE_DEFAULT_SIZE 8 typedef struct SeqQueue { ElemType *base; int capacity; int front; int rear; }SeqQueue; 2、初始化 void SeqQueueInit(SeqQueue* psq) { assert(psq != NULL); psq->capacity = QUEUE_DEFAULT_SIZE; psq->base = (ElemT
C++数据结构顺序队列（含完整代码）
qq_63184211的博客
02-10 439
允许插入的一端叫队尾，允许删除的一端叫队头。入队：在队列中插入元素；出队；空队列队列也叫先进先出（First In First Out）的线性表。操作：创建、入队、出队、获取队头数据、判断是否为空、判断是否为满；STL中有queue容器。分为顺序存储和链式存储。顺序存储：用一段连续的内存空间依次存储。
队列(Queue)
Catherine的笔记
05-26 1876
队列(Queue) 1. 队列的概念 1.1 队列的定义 队列是一种特殊的线性表，是一种运算受限的线性表。 队列是先进先出(FIFO，First In First Out)的线性表。 1.2 队列的逻辑结构和存储表示 队列的逻辑结构和线性表相同。 队列的抽象数据类型有两种典型的存储表示：基于数组的存储表示和基于链表的存储表示。 (1)基于数组的存储表示实现的队列称为顺序队列，顺序队列可以采用顺序表作为其存储
数据结构之队列
古月闻星
03-17 553
队列 @[.DataStructure] 文章目录队列 操作集 操作集合 解释 Queue CreatQueue( int MaxSize ) 生成长度为MaxSize的空队列。 int IsFullQ( Queue Q, int MaxSize )： 判断队列Q是否已满，若是返回1(TRUE)；否则返回0(FALSE)。 void AddQ( Queue Q, Eleme...
队列 顺序表实现
weixin_44836378的博客
04-14 805
#include <stdio.h> #include <assert.h> #include <Windows.h> #include <iostream> #include <iomanip> using namespace std; #define MaxSize 5 //队列的最大容量 typedef int DataType; //队列中元素类型 typedef struct Queue { DataType queue
计算机基础-数据结构与算法.pdf
10-07
数据结构与算法是计算机科学的基础，对于理解和优化程序性能至关重要。在这个领域，我们涉及的知识点广泛，主要包括数据结构如栈、队列、二叉树，以及解决哈希冲突的方法和各种排序算法。 栈是一种特殊线性表，遵循...
数据结构与算法-PPT课件
10-27
数据结构与算法是计算机科学中的核心课程，它探讨如何有效地组织和处理数据，以及如何设计和分析解决问题的算法。这份“数据结构与算法-PPT课件”提供了丰富的学习材料，涵盖了多个关键主题。 首先，我们要了解数据...
数据结构与算法-队列.pdf
07-11
队列是一种重要的数据结构，它的主要特点是先进先出（FIFO，First In First Out），意味着最早进入队列的元素也将是最早离开队列的。在队列中，主要有两个基本操作：入队（enqueue）和出队（dequeue）。入队操作是在...
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
数据结构--队列
weistar103的专栏
09-28 262
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 队列介绍 队列遵循FIFO（First In First Out，先进先出）原则的一组有序的项。 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行.
数据结构之线性队列
Arvin_success的博客
09-09 481
1、顺序队列 1.1、队列的定义 队列(queuq)简称队，它也是一种运算受限的线形表，其限制是仅允许在表的一端进行插入，而在表的另一端进行删除。我们把进行插入的一端称为队尾(rear),进行删除的一端称为队首（front）。向队列中插入新元素称作进队或入队，新元素进队后就成为新的队尾元素；从队列中删除元素称为出队，出队后，其后继元素成为队首元素。由于队列的插入和删除分别在两端进行，所以要删除
c++队列的基本操作_循环队列的概念及基本操作
weixin_35903340的博客
01-29 612
1.循环队列的概念为了克服顺序队列的“假上溢”现象，充分利用队列的存储空间，我们可以把队列想象成一个首尾相接的圆环，即将队列中的第一个元素接在最后一个元素的后面，我们称这样的队列为循环队列(Circular Queue)，如图3-7所示。循环队列入队、出队操作示意图图3-7(a)为队列初始状态,front=0,rear=0。图3-7(b)中，A、B、C、D、E五个元素依次入队，front=0,re...
队列和循环队列
qq_55895496的博客
04-16 142
#include<stdio.h> #include<stdlib.h> #include<iostream> #define LENGTH 10 using namespace std; typedef int datatype; typedef struct queue{ int data[LENGTH]; int front; int rear; }s_queue; void init_x_queue(s_queue *sq){ sq->fr.
C语言之队列（不记录size,用(rear+1)%maxsize==front判断队满,会浪费一个空间，实际容量为maxsize-1)
zhan_qian的博客
10-01 1141
#include<stdio.h> #include<stdlib.h> struct queue{ int *data; int front,rear; int maxsize; }; struct queue *create(int maxSize){ struct queue *q; q=malloc(sizeof(struct queue)); q->data=malloc(sizeof(int)*maxSize); .
队列的基本运算
南风花海的博客
11-16 1646
定义 队列（Queue）是只允许在一端进行插入，而在另一端进行删除的运算受限的线性表 （1）允许删除的一端称为队头（Front）。 （2）允许插入的一端称为队尾（Rear）。 （3）当队列中没有元素时称为空队列。 （4）队列亦称作先进先出（First In First Out）的线性表，简称为FIFO表。 队列的修改是依先进先出的原则进行的。 队头删除，队尾插入 ...
循环队列中公式的推导，原理，超详解
Error的博客
03-18 3930
我这里讲的是空闲单元法，如下图 首先规定 : front指向队列第一个元素 rear指向队列最后一个元素的下一个位置 假设maxsize=10 因为循环，需要保证front和rear的值始终在0-9之间循环，由此想到取余即% a%b当a<b时结果为a,a>=0,b>0 ，于是有了下方： rear=rear%maxsize front=front%maxsize 以下所有的操作都是rear和rear%maxsize，front和front%maxsize相互之间的替换
【数据结构】第三章:队列
qq_41514794的博客
03-17 188
队列(Queue):具有一定操作约束的线性表 特点：FIFO 即先来先服务，只能在一端插入，在另一端删除 顺序存储实现：由一个一维数组和一个记录头元素位置的变量front以及一个记录队尾元素位置的变量rear组成 #define Maxsize <存储数据元素的最大个数> struct QNode{ ElementType Data[Maxsize]; int...
平时积累的数据结构题
二哈喇子！
03-29 3840
平时学习遇到的数据结构题
队列——链队列和循环队列
大草的博客
11-03 8697
链队列 转载：https://www.cnblogs.com/muzijie/p/5655228.html 1 链队列的存储结构 　　将对头指针front指向链队列的头结点，队尾指针rear指向终端结点。 空队列时，头指针front和尾指针rear都指向头结点。   链队列的存储结构为： typedef int QElemType; typedef struct QNode...
数据结构与算法 - 队列
最新发布
09-12
队列（Queue）是一种先进先出（FIFO）的数据结构，类似于现实生活中排队的概念。它有两个基本操作：入队（enqueue）和出队（dequeue）。 入队操作将元素添加到队列的末尾，出队操作则从队列的头部移除元素并返回它...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值