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

最新推荐文章于 2022-06-25 16:34:46 发布
最新推荐文章于 2022-06-25 16:34:46 发布
阅读量534 收藏
点赞数
分类专栏： 数据结构和算法

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

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

FreeTourW
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
头歌数据结构循环队列及链队列的基本操作
05-18
头歌数据结构循环队列及链队列的基本操作 第1关循环队列的基本操作 第2关链队列的基本操作 稳过 栈是一种后进先出的数据结构，而在实际问题中还经常使用一种“先进先出”的数据结构。队列就是从日常生活中的排队现象抽象出来的线性表。
数据结构和算法系列4 队列
weixin_30799995的博客
07-28 61
上一篇讲了栈，这一篇要总结的是我们常用的队列，我想从以下几个方面进行总结。 1，什么是队列？ 2，队列的存储结构？ 3，队列的常用操作及实现代码？ 1，什么是队列 1，首先，队列也是一种特殊的线性表，它是一种操作受限的线性表。它只允许在表的一端进行元素插入，而在另一端进行元素删除。允许插入的一端称为队尾(rear)，允许删除的一端称为队头(font)。 2，对于队列...
数据结构与算法-队列
weixin_42570870的博客
05-23 240
目录数据结构与算法之队列基本介绍 数据结构与算法之队列 基本介绍 队列是一种有序的线性表，可以用数组和链表实现，只允许在队头和队尾进行操作，特点是先进先出的原则。 用数组声明一个简单的队列 具体方法，声明一个数组容器，两个指针，一个添加的指针，一个获取的指针， 添加时，添加指针后移，获取时，获取指针后移 代码示例： class ArrayQueue{ /** * 最大容量 */ private final int maxSize; /** * 队列头的前
数据结构与算法—队列
清风一阵吹我心
08-06 394
基本介绍 队列是一个有序列表，可以使用数组或链表来实现。 队列遵循先进先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出。 数组模拟队列 因为队列的输入、输出分别是从前后两端来处理的，所以定义两个变量front、rear来分别表示队列的前后端的下标。 下面就用代码来实现简单的队列。 代码实现 数组模拟队列 因为这里涉及到了两种不同结构的队列，普通的队列与环形队列。所以这里编写一个抽象类(AbstractQueue)，记录队列的公共方法。 队列都有添加数据(入队列)、获取数据(出队列)、打印数据(显
C++用栈实现队列
weixin_42326997的博客
11-05 423
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列的支持的所有操作（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, 和
数据结构与算法——栈和队列
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-25 1万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
数据结构与算法之队列
努力让自己发光，对的人才能迎着光而来
08-18 1万+
队列概念 队列的操作
数据结构和算法之优先队列算法实现.pdf
06-07
数据结构和算法之优先队列算法实现.pdf
Java数据结构与算法02——队列
12-21
标签：Java 数据结构 算法 作者 ： Maxchen 版本 ： V1.0.0 日期 ： 2020/3/29 目录1.队列的概念2.数组模拟队列3.队列运行测试 1.队列的概念 队列同样是一种特殊的线性表，其插入和删除的操作分别在表的两端进行，...
Python实现的数据结构与算法之双端队列详解
09-22
主要介绍了Python实现的数据结构与算法之双端队列,详细讲述了双端队列的概念、功能、定义及Python实现与使用双端队列的相关技巧,非常具有实用价值,需要的朋友可以参考下
Python数据结构与算法之使用队列解决小猫钓鱼问题
12-25
本文实例讲述了Python数据结构与算法之使用队列解决小猫钓鱼问题。分享给大家供大家参考，具体如下： 按照《啊哈》里的思路实现这道题目，但是和结果不一样，我自己用一幅牌试了一下，发现是我的结果像一点，可能我...
DataAndAlgorithm_C#数据结构与算法_栈和队列_
09-29
包含线性表，栈，队列，串等结构的代码示例，及一些栈和队列的应用。
数据结构与算法 －队列
越陌度阡
05-29 325
队列是只允许在表的一端进行插入，而在另一 端进行删除的线性表，也是一种运算受限的线性表。允许删除的一端称为队头(front)，允许插入的另一端称为队尾(rear)。 例如：排队购物，操作系统中的作业排队。先进入队列的成员总是先离开 队列，因此队列亦称作先进先出(First In First Out)的线性表，简称FIFO 表。 当队列中没有元素时称为空队列。在空队列中依次加入元素a1,a2,…an 之后，a1是队头元素，an是队尾元素。显然退出队列的次序也只能是 a1,a2,…an ，也就是说队列的
TCABEE 008-2020 轨道交通车站高效空调系统技术标准.docx
05-07
TCABEE 008-2020 轨道交通车站高效空调系统技术标准.docx
node-v5.12.0-x86.msi
05-07
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
基于阿里云的 ECS 部署 Ghost 博客内含源码以及说明书可以自己运行复现.zip
最新发布
05-07
基于阿里云的 ECS 部署 Ghost 博客内含源码以及说明书可以自己运行复现.zip
2023-04-06-项目笔记 - 第一百二十六阶段 - 4.4.2.124全局变量的作用域-124 -2024.05.07
05-07
2023-04-06-项目笔记-第一百二十六阶段-课前小分享_小分享1.坚持提交gitee 小分享2.作业中提交代码 小分享3.写代码注意代码风格 4.3.1变量的使用 4.4变量的作用域与生命周期 4.4.1局部变量的作用域 4.4.2全局变量的作用域 4.4.2.1全局变量的作用域_1 4.4.2.124全局变量的作用域_124 - 2024-05-07
node-v10.4.1-linux-armv7l.tar.xz
05-07
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
数据结构与算法c语言循环队列
10-12
循环队列的实现需要两个指针：front 和 rear，分别指向队头和队尾元素。当队列为空时，front 和 rear 指向同一个位置；当队列满时，rear 指向的位置是队尾元素，而 front 指向的位置是队头元素的下一个位置。 循环...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值