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

来源：互联网发布：同志名媛marc知乎编辑：程序博客网时间：2024/05/22 06:29

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

一：概念

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

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

二：存储结构

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

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

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

代码段如下：

 1     #region 队列的数据结构
 2     /// <summary>
 3 /// 队列的数据结构
 4 /// </summary>
 5 /// <typeparam name="T"></typeparam>
 6     public class SeqQueue<T>
 7     {
 8         private const int maxSize = 100;
 9 
10         public int MaxSize
11         {
12             get { return maxSize; }
13         }
14 
15         /// <summary>
16 /// 顺序队列的存储长度
17 /// </summary>
18         public T[] data = new T[maxSize];
19 
20         //头指针
21         public int head;
22 
23         //尾指针
24         public int tail;
25 
26     }
27     #endregion

三：常用操作

队列的操作一般分为：

①：初始化队列。

②: 出队。

③：入队。

④：获取队头。

⑤：获取队长。

1：初始化队列

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

2：出队

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

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

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

代码段如下：

 1 #region 队列元素出队
 2         /// <summary>
 3 /// 队列元素出队
 4 /// </summary>
 5 /// <typeparam name="T"></typeparam>
 6 /// <param name="seqQueue"></param>
 7 /// <returns></returns>
 8         public T SeqQueueOut<T>(SeqQueue<T> seqQueue)
 9         {
10             if (SeqQueueIsEmpty(seqQueue))
11                 throw new Exception("队列已空，不能进行出队操作");
12 
13             var single = seqQueue.data[seqQueue.head];
14 
15             //head指针自增
16             seqQueue.data[seqQueue.head++] = default(T);
17 
18             return single;
19 
20         }
21         #endregion

3：入队

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

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

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

代码段如下：

 1         #region 队列元素入队
 2         /// <summary>
 3 /// 队列元素入队
 4 /// </summary>
 5 /// <typeparam name="T"></typeparam>
 6 /// <param name="seqQueue"></param>
 7 /// <param name="data"></param>
 8 /// <returns></returns>
 9         public SeqQueue<T> SeqQueueIn<T>(SeqQueue<T> seqQueue, T data)
10         {
11             //如果队列已满，则不能进行入队操作
12             if (SeqQueueIsFull(seqQueue))
13                 throw new Exception("队列已满,不能入队操作");
14 
15             //入队操作
16             seqQueue.data[seqQueue.tail++] = data;
17 
18             return seqQueue;
19         }
20         #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)。

代码段如下：

 1   /// <summary>
 2 /// 获取队列长度
 3 /// </summary>
 4 /// <typeparam name="T"></typeparam>
 5 /// <param name="seqQueue"></param>
 6 /// <returns></returns>
 7         public int SeqQueueLen<T>(SeqQueue<T> seqQueue)
 8         {
 9             return seqQueue.tail - seqQueue.head;
10         }