数据结构和算法系列4 队列

最新推荐文章于 2023-05-25 21:01:14 发布
最新推荐文章于 2023-05-25 21:01:14 发布
阅读量503 收藏
点赞数
分类专栏： 编程语言 数据结构

上一篇讲了栈，这一篇要总结的是我们常用的队列，我想从以下几个方面进行总结。

1，什么是队列？
2，队列的存储结构？
3，队列的常用操作及实现代码？

1，什么是队列

1，首先，队列也是一种特殊的线性表，它是一种操作受限的线性表。它只允许在表的一端进行元素插入，而在另一端进行元素删除。允许插入的一端称为队尾(rear)，允许删除的一端称为队头(font)。

2，对于队列，与现实生活中的排队类似，新加入的成员总是在队尾，而排在队列最前面的总是最先离开队列，即先进先出，因此队列也称为先进先出表(FIFO)。

2，队列的存储结构

ds16

实现代码：

复制代码 
/// <summary>
    /// 封装顺序队列
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class SeqQueue<T>
    {
        private const int _maxSize = 100;
        public int MaxSize
        {
            get { return _maxSize; }
        }

        //保存数据
        public T[] data=new T[_maxSize];

        //头指针
        public int head;

        //尾指针
        public int rear;
    }
复制代码

3，队列的常见操作及实现代码

1，初始化队列

思路：构造一个空队列，即将头指针head和尾指针rear都设置为0。

2，入队

思路：若队列不满，则将数据x插入到尾指针rear指向的位置，然后再将rear加1。

3，出队

思路：若队列不空，则将头指针head加1，并返回被删除的元素。

4，取队头

思路：若队列不空，则返回队头元素。

5，取队长

思路：即尾指针rear-头指针head。

6，判队空

思路：只需要判断头指针head与尾指针是否相等即可

7，判队满

思路：只需判断尾指针与MaxSize是否相等即可

注：在一个非空队列中，头指针始终指向队头元素，而尾指针始终指向队尾元素的下一个位置。

C#版：

复制代码 
namespace DS.Model
{
    /// <summary>
    /// 学生实体
    /// </summary>
    public class Student
    {
        public int ID { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
    }
}

namespace DS.BLL
{
    /// <summary>
    /// 队列常见操作逻辑类
    /// </summary>
    public class SeqQueueBLL
    {
        /// <summary>
        /// 初始化
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="seqQueue"></param>
        /// <returns></returns>
        public static SeqQueue<T> Init<T>(SeqQueue<T> seqQueue)
        {
            seqQueue.head = 0;
            seqQueue.rear = 0;
            return seqQueue;
        }

        /// <summary>
        /// 入队
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="seqQueue"></param>
        /// <returns></returns>
        public static SeqQueue<T> Enter<T>(SeqQueue<T> seqQueue,T data)
        { 
            //是否队满
            if (IsFull(seqQueue)) return null;

            seqQueue.data[seqQueue.rear++] = data; //等价于seqQueue.data[seqQueue.rear] = data; seqQueue.rear++;
            return seqQueue;
        }

        /// <summary>
        /// 出队
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="seqQueue"></param>
        /// <returns></returns>
        public static T Dequeue<T>(SeqQueue<T> seqQueue)
        { 
            //是否队空
            if (IsEmpty(seqQueue)) return default(T);

            var data = seqQueue.data[seqQueue.head];
            seqQueue.head++;
            return data;
        }

        /// <summary>
        /// 取队头
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="seqQueue"></param>
        /// <returns></returns>
        public static T GetHead<T>(SeqQueue<T> seqQueue)
        { 
            //是否队空
            if(IsEmpty(seqQueue)) return default(T);

            return seqQueue.data[seqQueue.head];
        }

        /// <summary>
        /// 取队长
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="seqQueue"></param>
        /// <returns></returns>
        public static int GetLength<T>(SeqQueue<T> seqQueue)
        {
            return seqQueue.rear - seqQueue.head;
        }
        

        /// <summary>
        /// 判断是否队满
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="seqQueue"></param>
        /// <returns></returns>
        public static bool IsFull<T>(SeqQueue<T> seqQueue)
        {
            if (seqQueue.rear >= seqQueue.MaxSize) return true;
            return false;
        }

        /// <summary>
        /// 判断是否队空
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="seqQueue"></param>
        /// <returns></returns>
        public static bool IsEmpty<T>(SeqQueue<T> seqQueue)
        {
            if (seqQueue.head == seqQueue.rear) return true;
            return false;
        }
    }

    /// <summary>
    /// 封装顺序队列
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class SeqQueue<T>
    {
        private const int _maxSize = 100;
        public int MaxSize
        {
            get { return _maxSize; }
        }

        //保存数据
        public T[] data=new T[_maxSize];

        //头指针
        public int head;

        //尾指针
        public int rear;
    }
}

namespace SeqQueue.CSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            SeqQueue<Student> seqQueue = new SeqQueue<Student>();

            Console.WriteLine("********************初始化*******************\n");
            SeqQueueBLL.Init(seqQueue);
            Console.WriteLine("当前队列的长度是：{0}", SeqQueueBLL.GetLength(seqQueue));

            Console.WriteLine("\n********************入队*******************\n");
            Console.WriteLine("插入五条数据到队列\n");
            SeqQueueBLL.Enter(seqQueue, new Student { ID = 1, Name = "a", Age = 1 });
            SeqQueueBLL.Enter(seqQueue, new Student { ID = 2, Name = "b", Age = 2 });
            SeqQueueBLL.Enter(seqQueue, new Student { ID = 3, Name = "c", Age = 3 });
            SeqQueueBLL.Enter(seqQueue, new Student { ID = 4, Name = "d", Age = 4 });
            SeqQueueBLL.Enter(seqQueue, new Student { ID = 5, Name = "e", Age = 5 });
            Display(seqQueue);

            Console.WriteLine("\n********************出队*******************\n");
            Console.WriteLine("将队头出队\n");
            Student student= SeqQueueBLL.Dequeue(seqQueue);
            Display(seqQueue);

            Console.WriteLine("\n********************取队头*******************\n");
            Student result= SeqQueueBLL.GetHead(seqQueue);
            Console.WriteLine("ID={0},Name={1},Age={2}\n", result.ID, result.Name, result.Age);

            Console.WriteLine("\n********************取队长*******************\n");
            Console.WriteLine("当前队列中有{0}个元素\n",SeqQueueBLL.GetLength(seqQueue));

            Console.ReadKey();
        }

        /// <summary>
        /// 展示数据
        /// </summary>
        /// <param name="seqQueue"></param>
        private static void Display(SeqQueue<Student> seqQueue)
        {
            Console.WriteLine("\n*****展示数据*****\n");

            for (int i = seqQueue.head; i < seqQueue.rear; i++)
            {
                Console.WriteLine("ID={0},Name={1},Age={2}\n", seqQueue.data[i].ID, seqQueue.data[i].Name, seqQueue.data[i].Age);
            }
            Console.WriteLine("*****展示完毕*****\n");
        }
    }
}
复制代码

程序运行结果：

ds17-1

ds17-2

 

C语言版：

复制代码 
#include "stdio.h"    
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20

typedef int Status; 
typedef int ElemType;

/* 队列的顺序存储结构 */
typedef struct
{
    ElemType data[MAXSIZE];
    int head;        /* 头指针 */
    int rear;        /* 尾指针，若队列不空，指向队列尾元素的下一个位置 */
}SeqQueue;

/*初始化*/
Status Init(SeqQueue *seqQueue)
{
    seqQueue->head=0;
    seqQueue->rear=0;
    return OK;
}

/*入队*/
Status Enter(SeqQueue *seqQueue,ElemType e)
{
    //是否队满
    if (IsFull(seqQueue)) return ERROR;

    seqQueue->data[seqQueue->rear]=e;
    seqQueue->rear++;
    return OK;
    
}

/*出队*/
Status Dequeue(SeqQueue *seqQueue,ElemType *e)
{
    //是否队空
    if (IsEmpty(seqQueue)) return ERROR;
    
    *e=seqQueue->data[seqQueue->head]; //为什么不能用e=seqQueue->data[seqQueue->head]
    seqQueue->head++;
    return OK;
}

/*取队头*/
Status GetHead(SeqQueue *seqQueue,ElemType *e)
{
    //是否队空
    if (IsEmpty(seqQueue)) return ERROR;
    
    *e=seqQueue->data[seqQueue->head];
    return OK;
}

/*取队长*/
int GetLength(SeqQueue *seqQueue)
{
    return seqQueue->rear-seqQueue->head;
}

/*是否队满*/
Status IsFull(SeqQueue *seqQueue)
{
    if (seqQueue->rear>=MAXSIZE) return TRUE;
    return FALSE;
}

/*是否队空*/
Status IsEmpty(SeqQueue *seqQueue)
{
    if (seqQueue->rear==seqQueue->head) return TRUE;
    return FALSE;
}

/*展示数据*/
void Display(SeqQueue *seqQueue)
{
    int i;
    printf("*****展示数据*****\n");
    for (i=seqQueue->head;i<seqQueue->rear;i++)
    {
        printf("%d ",seqQueue->data[i]);
    }
    printf("\n*****展示完毕*****\n");
}

void main()
{
    SeqQueue seqQueue;
    ElemType e;
    Status i;
    int j;

    printf("***************初始化***************\n");
    i=Init(&seqQueue);
    if (i==OK) printf("初始化成功!\n");
    else printf("初始化失败!\n");

    printf("\n***************入队***************\n");
    printf("插入五条数据到队列\n");
    for (j=1;j<6;j++)
    {
        i=Enter(&seqQueue,j);
    }
    Display(&seqQueue);

    printf("\n***************出队***************\n");
    printf("将队头出队\n");
    Dequeue(&seqQueue,&e);
    Display(&seqQueue);

    printf("\n***************取队头***************\n");
    GetHead(&seqQueue,&e);
    printf("当前队头元素是：%d\n",e);

    printf("\n***************取队长***************\n");
    printf("当前队列中有%d个元素\n",GetLength(&seqQueue));
    
    getchar();
}
复制代码

程序运行结果：

ds18

悟之思语
关注
专栏目录
educoder数据结构与算法 队列 第1关：实现一个顺序存储的队列
qq_54008392的博客
12-09 1万+
任务描述 本关任务：实现 step1/SeqQueue.cpp 中的SQ_IsEmpty、SQ_IsFull、SQ_Length、SQ_In和SQ_Out五个操作函数，以实现判断队列是否为空、是否为满、求队列长度、队列元素入队和出队等功能。 相关知识 队列是一个插入操作和删除操作受到限制的线性表数据结构。队列的插入和删除被限制在表的两端，即插入操作只能在表的一端进行，而删除操作只能在表的另一端进行，因此队列又称先进先出表。 顺序存储的队列 队列既可以采用顺序存储，也可以采用链接存储来实现。下面给出
JS数据结构与算法.pdf
最新发布
11-01
本书主要介绍了 JavaScript 语言的基础知识，包括数据结构和算法。以下是该书的详细知识点： 一、JavaScript 基础知识 * 变量和数据类型 * 运算符和控制结构 * 函数和对象 * 数组和字符串 二、数据结构 * 数组：...
数据结构与算法-队列
weixin_42570870的博客
05-23 274
目录数据结构与算法之队列基本介绍 数据结构与算法之队列 基本介绍 队列是一种有序的线性表，可以用数组和链表实现，只允许在队头和队尾进行操作，特点是先进先出的原则。 用数组声明一个简单的队列 具体方法，声明一个数组容器，两个指针，一个添加的指针，一个获取的指针， 添加时，添加指针后移，获取时，获取指针后移 代码示例： class ArrayQueue{ /** * 最大容量 */ private final int maxSize; /** * 队列头的前
数据结构与算法—队列
清风一阵吹我心
08-06 443
基本介绍 队列是一个有序列表，可以使用数组或链表来实现。 队列遵循先进先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出。 数组模拟队列 因为队列的输入、输出分别是从前后两端来处理的，所以定义两个变量front、rear来分别表示队列的前后端的下标。 下面就用代码来实现简单的队列。 代码实现 数组模拟队列 因为这里涉及到了两种不同结构的队列，普通的队列与环形队列。所以这里编写一个抽象类(AbstractQueue)，记录队列的公共方法。 队列都有添加数据(入队列)、获取数据(出队列)、打印数据(显
头歌数据结构与算法——队列
weixin_62440328的博客
10-25 8031
【代码】头歌数据结构与算法——队列。
Python实现的数据结构与算法之双端队列详解
12-25
本文实例讲述了Python实现的数据结构与算法之双端队列。分享给大家供大家参考。具体分析如下： 一、概述 双端队列（deque，全名double-ended queue）是一种具有队列和栈性质的线性数据结构。双端队列也拥有两端：队...
Python实现的数据结构与算法之队列详解
12-25
本文实例讲述了Python实现的数据结构与算法之队列。分享给大家供大家参考。具体分析如下： 一、概述 队列（Queue）是一种先进先出（FIFO）的线性数据结构，插入操作在队尾（rear）进行，删除操作在队首（front）进行...
C++数据结构与算法 （第4版）
01-06
通过以上内容可以看出，《C++数据结构与算法（第4版）》这本书旨在全面介绍数据结构的基本概念、常用的数据结构类型、典型排序和查找算法，以及算法设计与分析的方法和技术。这些知识点对于学习计算机科学和编程语言...
头歌数据结构循环队列及链队列的基本操作
05-18
头歌数据结构循环队列及链队列的基本操作 第1关循环队列的基本操作 第2关链队列的基本操作 稳过 栈是一种后进先出的数据结构，而在实际问题中还经常使用一种“先进先出”的数据结构。队列就是从日常生活中的排队现象抽象出来的线性表。
【数据结构实验】队列的应用
06-15
1.实验目的： 熟悉队列的定义，队列的特点以及队列的基本操作。能够根据实际情况选择合适的存储结构，解决实际问题。 2.实验内容： 利用循环队列模拟舞伴配对问题： 1、利用循环队列模拟舞伴配对问题。在舞会上，男、女各自排成一队。舞会开始时。依次从男队和女队的队头各出一人配成舞伴。如果两队初始人数不等，则较长的那一队中未配对者等待下一轮舞曲。 2、假设初始男、女人数及性别已经固定，舞会的轮数从键盘输入。 试模拟解决上述舞伴配对问题。 3、从屏幕输出每一轮舞伴配对名单，如果在该轮有未配对的，能够从屏幕显示下一轮第一个出场的未配对者的姓名。
头歌 顺序表，链表，循环队列的基本操作和应用答案。
05-03
头歌数据结构的题目： 顺序表的基本操作和应用 链表的基本操作和应用， 循环队列的应用 同时还有一些附加题，n皇后和钓鱼
C++用栈实现队列
weixin_42326997的博客
11-05 488
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列的支持的所有操作（push、pop、peek、empty）： 实现 MyQueue 类： void push(int x) 将元素 x 推到队列的末尾 int pop() 从队列的开头移除并返回元素 int peek() 返回队列开头的元素 boolean empty() 如果队列为空，返回 true ；否则，返回 false 说明： 你只能使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和
数据结构与算法 －队列
越陌度阡
05-29 344
队列是只允许在表的一端进行插入，而在另一 端进行删除的线性表，也是一种运算受限的线性表。允许删除的一端称为队头(front)，允许插入的另一端称为队尾(rear)。 例如：排队购物，操作系统中的作业排队。先进入队列的成员总是先离开 队列，因此队列亦称作先进先出(First In First Out)的线性表，简称FIFO 表。 当队列中没有元素时称为空队列。在空队列中依次加入元素a1,a2,…an 之后，a1是队头元素，an是队尾元素。显然退出队列的次序也只能是 a1,a2,…an ，也就是说队列的
【头歌】数据结构-队列的应用
wx_15774293141的博客
05-25 7540
任务描述本关任务：编写一个循环队列，实现入队、出队操作，判断队空、队满等特殊情况。相关知识为了完成本关任务，你需要掌握：1.循环队列定义，2.入队、出队的定义，3.队空、队满的情况。循环队列定义循环队列将数组存储区看成是一个首尾相接的环形区域（下图）。当数据存放到尾地址后，下一个地址就跳转到首地址。循环队列定义如下：入队出队定义入队操作：队列未满，在队尾插入一个元素item，使得，若超过存储空间则尾指针索引取模；出队操作：队列不空，返回队首元素值，并移除队首元素front+1。
数据结构与算法：队列（Queue）的实现
极歌科技
05-08 279
在数据结构当中，有一种结构叫做队列。队列和栈都是一个类似于列表的东西，唯一不同的地方则是“先进先出”。队列就像我们在食堂排队吃饭一样，先排队的同学最先打到饭，下面是我画的队列的图片： 从这种图当中我们可以看到队列就如同一个吸管一样，最先从吸管左边进入的数字1，同时也最先吸管的最右边出来。是否十分容易理解呢？现在我们使用Python来实现这个数据结构： class Queue(): ...
数据结构_队列及其应用
xc13212777631的博客
06-05 2139
除了顺序容器外，标准库还定义了三个顺序容器适配器，stack、queue和priority_queue。本质上一个适配器是一种机制，能使某种事物的行为看起来像另外一种事物一样。一个容器适配器接收一种已有的容器类型，使其行为看起来像另外一种不同类型一样。 本文主要介绍队列及其应用，栈及其应用参考栈及其应用 ，优先级队列参考 队列 /*queue默认基于deque实现，也可以使用list或v...
C#实现数据结构与算法：栈和队列应用实例
资源摘要信息:"本资源主要介绍了C#数据结构与算法中关于栈和队列的实现与应用。资源详细解析了线性表、栈、队列以及串等基本数据结构的概念和性质，并提供了相应的代码示例。同时，资源还涵盖了栈和队列的一些应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值