算法系列15天速成——第九天 队列

最新推荐文章于 2024-04-25 13:56:39 发布
最新推荐文章于 2024-04-25 13:56:39 发布
阅读量2.4k 收藏 2
点赞数
分类专栏： 工作心得 算法系列 算法系列15天速成 文章标签： 算法 exception 数据结构 class 存储 string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m13666368773/article/details/7530196
版权

五一回老家待了几天，昨天晚上回来看见有很多网友留言，谢谢支持，继续写点东东奉献给大家

 

可能大家都知道，线性表的变种非常非常多，比如今天讲的“队列”，灰常有意思啊。

 

一：概念

          队列是一个”先进先出“的线性表，牛X的名字就是“First in First Out(FIFO)”，

      生活中有很多这样的场景，比如读书的时候去食堂打饭时的”排队“。当然我们拒绝插队。

 

二：存储结构

         前几天也说过，线性表有两种”存储结构“，① 顺序存储,②链式存储。当然“队列”也脱离

     不了这两种服务，这里我就分享一下“顺序存储”。

     顺序存储时，我们会维护一个叫做”head头指针“和”tail尾指针“，分别指向队列的开头和结尾。

 

代码段如下：

复制代码 
#region 队列的数据结构
     /// <summary>
 /// 队列的数据结构
 /// </summary>
 /// <typeparam name="T"></typeparam>
     public class SeqQueue<T>
     {
         private const int maxSize = 100;
 
         public int MaxSize
         {
             get { return maxSize; }
         }
 
         /// <summary>
 /// 顺序队列的存储长度
 /// </summary>
         public T[] data = new T[maxSize];
 
         //头指针
         public int head;
 
         //尾指针
         public int tail;
 
     }
     #endregion

 复制代码

 

三：常用操作

      队列的操作一般分为：

      ①： 初始化队列。

      ②:   出队。

      ③： 入队。

      ④： 获取队头。

      ⑤： 获取队长。

 

1：初始化队列

        这个很简单，刚才也说过了，队列是用一个head和tail的指针来维护。分别设置为0即可。

 

2：出队

       看着“队列”的结构图，大家都知道，出队肯定跟head指针有关，需要做两件事情，

       第一： 判断队列是否为空，这个我想大家都知道。

       第二： 将head头指针向后移动一位，返回head移动前的元素，时间复杂度为O(1)。

   

代码段如下：

复制代码  
#region 队列元素出队
         /// <summary>
 /// 队列元素出队
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="seqQueue"></param>
 /// <returns></returns>
         public T SeqQueueOut<T>(SeqQueue<T> seqQueue)
         {
             if (SeqQueueIsEmpty(seqQueue))
                 throw new Exception("队列已空，不能进行出队操作");
 
             var single = seqQueue.data[seqQueue.head];
 
             //head指针自增
             seqQueue.data[seqQueue.head++] = default(T);
 
             return single;
 
         }
         #endregion



3：入队

      这个跟”出队“的思想相反，同样也是需要做两件事情。

      第一：判断队列是否已满。

      第二：将tail指针向后移动一位，时间复杂度为O(1)。

代码段如下：

复制代码 
#region 队列元素入队
         /// <summary>
 /// 队列元素入队
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="seqQueue"></param>
 /// <param name="data"></param>
 /// <returns></returns>
         public SeqQueue<T> SeqQueueIn<T>(SeqQueue<T> seqQueue, T data)
         {
             //如果队列已满，则不能进行入队操作
             if (SeqQueueIsFull(seqQueue))
                 throw new Exception("队列已满,不能入队操作");
 
             //入队操作
             seqQueue.data[seqQueue.tail++] = data;
 
             return seqQueue;
         }
         #endregion


4： 获取队头

       知道”出队“和”入队“的原理，相信大家都懂的如何进行”获取队头“操作，唯一不一样的就是

       他是只读操作，不会破坏”队列“结构，时间复杂度为O（1）。

 

代码段如下：

复制代码 
#region 获取队头元素
        /// <summary>
        /// 获取队头元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="seqQueue"></param>
        /// <returns></returns>
        public T SeqQueuePeek<T>(SeqQueue<T> seqQueue)
        {
            if (SeqQueueIsEmpty(seqQueue))
                throw new Exception("队列已空，不能进行出队操作");

            return seqQueue.data[seqQueue.head];
        }
        #endregion


5: 获取队长

       大家都知道，我们是用数组来实现队列，所以千万不要想当然的认为数组长度是XXX，

       我们维护的是一个head和tail的指针，所以长度自然就是tail-head咯，时间复杂度为O(1)。

代码段如下：

复制代码 
/// <summary>
 /// 获取队列长度
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="seqQueue"></param>
 /// <returns></returns>
         public int SeqQueueLen<T>(SeqQueue<T> seqQueue)
         {
             return seqQueue.tail - seqQueue.head;
         }

 

然后上一下总的运行代码：

View Code 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
 namespace SeqQueue
 {
     public class Program
     {
         static void Main(string[] args)
         {
             SeqQueue<Student> seqQueue = new SeqQueue<Student>();
 
             SeqQueueClass queueManage = new SeqQueueClass();
 
             Console.WriteLine("目前队列是否为空：" + queueManage.SeqQueueIsEmpty(seqQueue) + "\n");
 
             Console.WriteLine("将ID=1和ID=2的实体加入队列");
             queueManage.SeqQueueIn(seqQueue, new Student() { ID = 1, Name = "hxc520", Age = 23 });
             queueManage.SeqQueueIn(seqQueue, new Student() { ID = 2, Name = "一线码农", Age = 23 });
 
             Display(seqQueue);
 
             Console.WriteLine("将队头出队");
             //将队头出队
             var student = queueManage.SeqQueueOut(seqQueue);
 
             Display(seqQueue);
 
             //获取队顶元素
             student = queueManage.SeqQueuePeek(seqQueue);
 
             Console.Read();
         }
         //展示队列元素
         static void Display(SeqQueue<Student> seqQueue)
         {
             Console.WriteLine("******************* 链表数据如下 *******************");
 
             for (int i = seqQueue.head; i < seqQueue.tail; i++)
                 Console.WriteLine("ID:" + seqQueue.data[i].ID +
                                   ",Name:" + seqQueue.data[i].Name +
                                   ",Age:" + seqQueue.data[i].Age);
 
             Console.WriteLine("******************* 链表数据展示完毕 *******************\n");
         }
     }
 
     #region 学生数据实体
     /// <summary>
 /// 学生数据实体
 /// </summary>
     public class Student
     {
         public int ID { get; set; }
 
         public string Name { get; set; }
 
         public int Age { get; set; }
     }
     #endregion
 
     #region 队列的数据结构
     /// <summary>
 /// 队列的数据结构
 /// </summary>
 /// <typeparam name="T"></typeparam>
     public class SeqQueue<T>
     {
         private const int maxSize = 100;
 
         public int MaxSize
         {
             get { return maxSize; }
         }
 
         /// <summary>
 /// 顺序队列的存储长度
 /// </summary>
         public T[] data = new T[maxSize];
 
         //头指针
         public int head;
 
         //尾指针
         public int tail;
 
     }
     #endregion
 
     #region 队列的基本操作
     /// <summary>
 /// 队列的基本操作
 /// </summary>
     public class SeqQueueClass
     {
         #region 队列的初始化操作
         /// <summary>
 /// 队列的初始化操作
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="seqQueue"></param>
         public SeqQueue<T> SeqQueueInit<T>(SeqQueue<T> seqQueue)
         {
             seqQueue.head = 0;
             seqQueue.tail = 0;
 
             return seqQueue;
         }
         #endregion
 
         #region 队列是否为空
         /// <summary>
 /// 队列是否为空
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="seqQueue"></param>
 /// <returns></returns>
         public bool SeqQueueIsEmpty<T>(SeqQueue<T> seqQueue)
         {
             //如果两指针重合，说明队列已经清空
             if (seqQueue.head == seqQueue.tail)
                 return true;
             return false;
         }
         #endregion
 
         #region 队列是否已满
         /// <summary>
 /// 队列是否已满
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="seqQueue"></param>
 /// <returns></returns>
         public bool SeqQueueIsFull<T>(SeqQueue<T> seqQueue)
         {
             //如果尾指针到达数组末尾，说明队列已经满
             if (seqQueue.tail == seqQueue.MaxSize)
                 return true;
             return false;
         }
         #endregion
 
         #region 队列元素入队
         /// <summary>
 /// 队列元素入队
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="seqQueue"></param>
 /// <param name="data"></param>
 /// <returns></returns>
         public SeqQueue<T> SeqQueueIn<T>(SeqQueue<T> seqQueue, T data)
         {
             //如果队列已满，则不能进行入队操作
             if (SeqQueueIsFull(seqQueue))
                 throw new Exception("队列已满,不能入队操作");
 
             //入队操作
             seqQueue.data[seqQueue.tail++] = data;
 
             return seqQueue;
         }
         #endregion
 
         #region 队列元素出队
         /// <summary>
 /// 队列元素出队
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="seqQueue"></param>
 /// <returns></returns>
         public T SeqQueueOut<T>(SeqQueue<T> seqQueue)
         {
             if (SeqQueueIsEmpty(seqQueue))
                 throw new Exception("队列已空，不能进行出队操作");
 
             var single = seqQueue.data[seqQueue.head];
 
             //head指针自增
             seqQueue.data[seqQueue.head++] = default(T);
 
             return single;
 
         }
         #endregion
 
         #region 获取队头元素
         /// <summary>
 /// 获取队头元素
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="seqQueue"></param>
 /// <returns></returns>
         public T SeqQueuePeek<T>(SeqQueue<T> seqQueue)
         {
             if (SeqQueueIsEmpty(seqQueue))
                 throw new Exception("队列已空，不能进行出队操作");
 
             return seqQueue.data[seqQueue.head];
         }
         #endregion
 
         /// <summary>
 /// 获取队列长度
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="seqQueue"></param>
 /// <returns></returns>
         public int SeqQueueLen<T>(SeqQueue<T> seqQueue)
         {
             return seqQueue.tail - seqQueue.head;
         }
     }
     #endregion
 }

 

 

 

三：顺序队列的缺陷

大家看这张图，不知道可有什么异样的感觉，在这种状态下，我入队操作，发现程序提示队列

已满，但是tnd我这个数组还有一个空间啊，是的，这就是所谓的“假溢出”。

 

四：循环队列

 

俗话说的好啊，“没有跨不过的坎”。

 

1: 概念

       之所以叫“循环”，得益于神奇的“%”。他让队列的首位进行相连，形成了一个我们思维中的

       “圈圈”。

 

2：循环公式

      tail=(tail+1)%array.Length;

      多看几眼，大家就看通了其中循环的道理，我要做成如下的图:

 

3：对循环的改造

      先前看了一些资料，有的压根就是错的，有的说想要循环，就要牺牲一个单位的空间。

      我觉得没必要。我既要循环又不牺牲空间，所以反射了一下framework中的Queue类。

      改造后代码如下：

 

View Code 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
 namespace SeqQueue
 {
     public class Program
     {
         static void Main(string[] args)
         {
             SeqQueue<Student> seqQueue = new SeqQueue<Student>();
 
             SeqQueueClass queueManage = new SeqQueueClass();
 
             Console.WriteLine("目前队列是否为空：" + queueManage.SeqQueueIsEmpty(seqQueue) + "\n");
 
             Console.WriteLine("将ID=1，2，3的实体加入队列\n");
             queueManage.SeqQueueIn(seqQueue, new Student() { ID = 1, Name = "hxc520", Age = 23 });
             queueManage.SeqQueueIn(seqQueue, new Student() { ID = 2, Name = "一线码农", Age = 23 });
             queueManage.SeqQueueIn(seqQueue, new Student() { ID = 3, Name = "51cto", Age = 23 });
 
             Console.WriteLine("\n当前队列个数：" + queueManage.SeqQueueLen(seqQueue) + "");
 
             Console.WriteLine("\n*********************************************\n");
 
             Console.WriteLine("我要出队了\n");
             queueManage.SeqQueueOut(seqQueue);
 
             Console.WriteLine("哈哈，看看跟顺序队列异样之处，我再入队，看是否溢出\n");
             queueManage.SeqQueueIn(seqQueue, new Student() { ID = 4, Name = "博客园", Age = 23 });
             Console.WriteLine("\n....一切正常，入队成功");
 
             Console.WriteLine("\n当前队列个数：" + queueManage.SeqQueueLen(seqQueue) + "");
 
             Console.Read();
         }
     }
 
     #region 学生数据实体
     /// <summary>
 /// 学生数据实体
 /// </summary>
     public class Student
     {
         public int ID { get; set; }
 
         public string Name { get; set; }
 
         public int Age { get; set; }
     }
     #endregion
 
     #region 队列的数据结构
     /// <summary>
 /// 队列的数据结构
 /// </summary>
 /// <typeparam name="T"></typeparam>
     public class SeqQueue<T>
     {
         private const int maxSize = 3;
 
         public int MaxSize
         {
             get { return maxSize; }
         }
 
         /// <summary>
 /// 顺序队列的存储长度
 /// </summary>
         public T[] data = new T[maxSize];
 
         //头指针
         public int head;
 
         //尾指针
         public int tail;
 
         //队列中有效的数字个数
         public int size;
     }
     #endregion
 
     #region 队列的基本操作
     /// <summary>
 /// 队列的基本操作
 /// </summary>
     public class SeqQueueClass
     {
         #region 队列的初始化操作
         /// <summary>
 /// 队列的初始化操作
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="seqQueue"></param>
         public SeqQueue<T> SeqQueueInit<T>(SeqQueue<T> seqQueue)
         {
             seqQueue.size = seqQueue.head = seqQueue.tail = 0;
 
             return seqQueue;
         }
         #endregion
 
         #region 队列是否为空
         /// <summary>
 /// 队列是否为空
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="seqQueue"></param>
 /// <returns></returns>
         public bool SeqQueueIsEmpty<T>(SeqQueue<T> seqQueue)
         {
             //如果两指针重合，说明队列已经清空
             if (seqQueue.size == 0)
                 return true;
             return false;
         }
         #endregion
 
         #region 队列是否已满
         /// <summary>
 /// 队列是否已满
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="seqQueue"></param>
 /// <returns></returns>
         public bool SeqQueueIsFull<T>(SeqQueue<T> seqQueue)
         {
             //采用循环队列后，头指针
             if (seqQueue.size == seqQueue.MaxSize)
                 return true;
             return false;
         }
         #endregion
 
         #region 队列元素入队
         /// <summary>
 /// 队列元素入队
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="seqQueue"></param>
 /// <param name="data"></param>
 /// <returns></returns>
         public SeqQueue<T> SeqQueueIn<T>(SeqQueue<T> seqQueue, T data)
         {
             //如果队列已满，则不能进行入队操作
             if (SeqQueueIsFull(seqQueue))
                 throw new Exception("队列已满，还入啥队列啊！");
 
             //采用循环队列,必须先赋值，在自增tail指针
             seqQueue.data[seqQueue.tail] = data;
             seqQueue.tail = (seqQueue.tail + 1) % seqQueue.MaxSize;
 
             //队列实际元素增加
             seqQueue.size++;
 
             return seqQueue;
         }
         #endregion
 
         #region 队列元素出队
         /// <summary>
 /// 队列元素出队
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="seqQueue"></param>
 /// <returns></returns>
         public T SeqQueueOut<T>(SeqQueue<T> seqQueue)
         {
             if (SeqQueueIsEmpty(seqQueue))
                 throw new Exception("队列已空，大哥，不要在出队了！");
 
             //循环队列出队，展现的是head的灵活性
             seqQueue.head = (seqQueue.head + 1) % seqQueue.MaxSize;
 
             //队列实际元素递减
             seqQueue.size--;
 
             return seqQueue.data[seqQueue.head];
         }
         #endregion
 
         #region 获取队头元素
         /// <summary>
 /// 获取队头元素
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="seqQueue"></param>
 /// <returns></returns>
         public T SeqQueuePeek<T>(SeqQueue<T> seqQueue)
         {
             if (SeqQueueIsEmpty(seqQueue))
                 throw new Exception("队列已空，不能进行出队操作");
 
             return seqQueue.data[seqQueue.head];
         }
         #endregion
 
         #region 获取队列长度
         /// <summary>
 /// 获取队列长度
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="seqQueue"></param>
 /// <returns></returns>
         public int SeqQueueLen<T>(SeqQueue<T> seqQueue)
         {
             return seqQueue.size;
         }
         #endregion
     }
     #endregion
 }

 

 

m13666368773
关注
专栏目录
华为OD机试知识点1周速成版——如果考试时间只有1周，不妨看看这篇文章
weixin_48157259的博客
12-28 2111
距离机考时间还有一个月以上的同学可以忽略这篇内容，安安心心跟着正课从头到尾学习就可以了。但如果你的时间非常紧急，但基础仍不牢固，可以参考以下内容。优先级5表示优先级最高，1表示优先级最低难易度5表示知识点最难，1表示知识点最简单相关文档或题目只罗列了最重要的部分内容，其他内容请详见等文档。如果备考时间仅剩1周，那么优先学习所有优先级 == 5的内容，以及优先级 == 4且难易度 <= 3的内容如果备考时间仅剩2周，那么优先学习所有优先级 >= 3的内容的内容。
【大总结2】大学两年，写了这篇几十万字的干货总结_万字 cndn
最新发布
2401_84617533的博客
04-27 817
这部分在我看来是最有意思的，我们有必要了解底层数据结构的实现，这也是我最感兴趣的。比如，你知道redis中的字符串怎么实现的吗？为什么这么实现？你知道redis压缩列表是什么算法吗？你知道redis为什么抛弃了红黑树反而采用了跳表这种新的数据结构吗？你知道hyperloglog为什么用如此小的空间就可以有这么好的统计性能和准确性吗？你知道布隆过滤器为什么这么有效吗？有没有数学证明过？你是否还能很快写出来快排？或者不断优化性能的排序？是不是只会调库了甚至库函数怎么实现的都不知道？真的就是快排？
队列相关算法
08-25
1、定义队列类。 2、实验验证如下算法的正确性、各种功能及指标： 1）创建队列； 2）插入操作：向队尾插入值为x的元素； 3）删除操作：删除队首元素； 4）存取操作：读取队首元素。 3、为便于观察程序的运行结果，设计的输出函数能在输出设备上以 图形或表格或其它直观的形式展现、存储计算结果。 4、测试程序时，对所有输入变量取遍各种有代表性的值。 5、为了增强程序的可读性，程序中要有适当的注释。
队列算法
jenie的专栏
04-29 1197
一：概念 队列是一个”先进先出“的线性表，牛X的名字就是“First in First Out(FIFO)”， 生活中有很多这样的场景，比如读书的时候去食堂打饭时的”排队“。当然我们拒绝插队。 二：存储结构 前几天也说过，线性表有两种”存储结构“，① 顺序存储,②链式存储。当然“队列”也脱离 不了这两种服务，这里我就分享一...
队列的算法
weixin_41687289的博客
09-10 268
import random class Queue: def __init__(self): self.queue = [] def destroy(self): self.queue.clear() def clear(self): self.queue.clear() def is_empty(self): ...
一步一步写算法（之线性队列）
javasee
10-07 131
【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 这里的线性结构实际上指的就是连续内存的意思，只不过使用“线性”这个词显得比较专业而已。前面一篇博客介绍了现象结构的处理方法，那么在这个基础之上我们是不是添加一些属性形成一种新的数据结构类型呢？答案是肯定的，队列便是其中的一种。 队列的性质很简单： （1）队列有头部和尾部 （2...
算法九：队列
闲狗的博客
05-24 558
描述实现一个队列，完成以下功能：入列出列询问队列中位置Y是谁一开始队列为空。队列中的位置从1开始（即队头位置为1）。输入第一行一个整数n，表示操作个数。接下来n行，每行第一个数字表示操作（见描述）：若为数字1，则接下来有一串字符串X，表示将X加入队列。若为数字2，表示出列（保证队列非空），并输出出列的这个人。若为数字3，则接下来有一个整数Y，表示询问队列中位置Y是谁（保证位置Y合法），并输出名字。...
数据结构算法
05-02
树操作【中】 算法系列15天速成——第十一天 树操作（上） 算法系列15天速成——第十天 栈 算法系列15天速成——第九天 队列 算法系列15天速成——第八天 线性表【下】 算法系列15天速成——第七天 线性表【上】 ...
2024全新Java学习路线图一条龙（视频+课件+源码资料）
码农王也的博客
04-25 1610
互联网浩瀚无际，你能来到这里，是机遇也是缘分，机遇，就像我的标题一样，你找到了一份Java 360度无死角的 Java 学习路线，而缘分让我们相遇，注定给你的学习之路搭上一把手，送你一程。整条线路除了拥有后端整个技术体系外，还涵盖了前端、大数据、云计算、运维等各大领域。在这十八般武艺汇聚全身的同时，这条学习路线也拥有着独有的特色和着重点，比如加入了极为重要且业内稀缺的基本功修炼——六套计算机基础类课程。还有多套Java基础类课程，多维度讲解帮助学习者入门。
队列（算法与数据结构）
02-15
队列（算法与数据结构）包含顺序队列和链表队列两种
数据结构 队列算法
05-29
天大 数据结构课 作业 实验 源代码 超级好用
面试技巧 面试复盘 编程技术 架构 看这一篇就够了
china19931017的博客
11-25 2230
神经网路与深度学习 Kubernetes实战 大型网站性能监测、分析与优化 Flume日志收集与MapReduce模式 ZooKeeper：分布式过程协同技术详解 自己动手写Java虚拟机 Java WebSocket编程 开发、部署和保护动态Web应用 SpringBoot揭秘：快速构建微服务体系 Web全栈工程师的自我修养 Apache Spark源码剖析 Wireshark数据包分析实战详解 深入剖析Tomcat-网上版本不够清晰 故重做 Kafka技术内幕 图文详解Kafka
算法：队列
xuzhimolol的博客
06-16 478
算法的系列文章中，之前咱们已经聊过了「 数组和链表 」、「 堆栈 」，今天咱们再来继续看看「 队列 」这种数据结构。「 队列 」和「 堆栈 」比较类似，都属于线性表数据结构，并且都在操作上受到一定规则约束，都是非常常用的数据类型，咱们掌握得再熟练也不为过。 一、「 队列 」是什么？ 队列（queue）是一种先进先出的、操作受限的线性表。 队列这种数据结构非常容易理解，就像我们平时去超市买东西，在收银台结账的时候需要排队，先去排队的就先结账出去，排在后面的就后结账，有其他人再要过来结账，必须排在队.
算法 --- 队列
Gerald的博客
09-26 505
算法学习 栈、队列、链表 解密QQ号 -- 队列    先对队列来一个定义：队列是一种特殊的线性结构，它只允许在队列的首部（head）进行删除操作，这称为“出队”，而在队列的尾部（tail）进行插入操作，这称为“入队”。当队列中没有元素时（即 head == tail），这称为空队列。    队列遵守“先进先出”原则！    举个例子！    当你问一个女生要QQ号的时候，那个女生并不...
7.队列算法
感谢关注-最近在编写开源的自动化测试框架还没整理完
04-22 1317
队列是一种抽象的数据结构，有点类似于Stacks。与堆栈不同，队列的两端都是开放的。一端始终用于插入数据(入队)，另一端用于删除数据(出队)。队列遵循先进先出方法，即首先访问先存储的数据项。一个真实的队列示例可以是单车道单向道路，车辆首先进入，首先退出。更多真实世界的例子可以看作是售票窗口和公共汽车站的队列。
队列算法的讲解
psr博客
12-22 575
@TOC队列的定义 @TOC队列示意图 @TOC队列代码 队列算法的讲解 队列算法目前还是使用得比较多的一种数据结构，比如Linux的内核监测cpu性能，一些大型的项目需要对数据进行先后采集的，等等，都基本上使用队列比较方便，今天讨论的是队列的一般性数组性质的用法。 队列的定义 队列是一种数据结构，特点是“先进先出(FIFO)”，就类似于我们排队一样，所以队列在同步数据中还是有一定的优势的，因为必...
对队列的操作和算法
weixin_30458043的博客
09-19 149
一、队列的定义 队列（queue）是一种先进先出的线性表。它只允许在表的一端进行插入，而在另一端删除元素。 允许插入的一端叫做队尾（rear），允许删除的一端则称为对头（front）。 队列一般也分为两种： 链式队列：用链表实现； 静态队列：用数组实现（静态队列通常都必须是循环队列）。 一般用循环队列比较多，这里也只是讲述循环队列。 二、循环队列需要弄清楚的几个问题 ...
算法入门（二）队列
itjiangpo的博客
07-20 399
问题引入 很久很久以前，我们的阿三同学喜欢上了如花，然后阿三就问如花要她的扣扣。然后如花这个就不太愿意吼！就给了阿三一串数字让他解密！ 阿三：如花，我可以拥有你的扣扣号嘛？ 如花：那倒也不是不可以，听说你会开挂，把这串数字用我给你的解码方式解开，你就能得到我的扣扣号了！ 于是阿三就开始了开挂之路，搞错了，是解码之路，先让我们看看这串数字 " 6 3 1 7 5 8 9 2 4 " 。 解码规则是：首先将第 1 个数删除，紧接着将第 2 个数放到 这串数的末尾，再将第 3 个数删除并将第 4 个.
算法15天速成：七大经典排序——冒泡排序对决快速排序
"算法系列15天速成——第一天七大经典排序【上】 在这个15天的算法速成系列中，我们将深入探讨数据结构与算法，特别是重点讲解树、图、堆栈、队列等核心概念。算法是编程的基础，就像剑客手中的利剑，能够高效地...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值