算法：基于 RingBuffer 的 Queue 实现

背景

如果基于数组实现队列，常见的选择是采用 RingBuffer，否则就需要移动数组元素。

RingBuffer

很容易看出 RingBuffer 的思想，这里就不赘述了。

您可以思考一个问题：图中表示的场景是一个空队列？还是一个满队列？答案是：单单维护 _header 和 _tail 还不足以判断，必须维护一个 _count 计数。

ArrayQueue

代码

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace DataStuctureStudy.Queues
 {
     public class ArrayQueue<T>
     {
         private readonly int _maxSize;
         private readonly T[] _items;
         private int _count = ;
         private int _header = ;
         private int _tail;
 
         public ArrayQueue(int size)
         {
             _maxSize = size;
             _items = new T[size];
             _tail = _maxSize - ;
         }
 
         public void EnQueue(T item)
         {
             if (this.IsFull())
             {
                 throw new InvalidOperationException("队列已满");
             }
 
             if (_tail == _maxSize - )
             {
                 _tail = -;
             }
 
             _items[++_tail] = item;
 
             _count++;
         }
 
         public T DeQueue()
         {
             if (this.IsEmpty())
             {
                 throw new InvalidOperationException("队列已空");
             }
 
             T item = _items[_header++];
 
             if (_header == _maxSize)
             {
                 _header = ;
             }
 
             _count--;
 
             return item;
         }
 
         public T Peek()
         {
             if (this.IsEmpty())
             {
                 throw new InvalidOperationException("队列已空");
             }
 
             return _items[_header];
         }
 
         public bool IsFull()
         {
             return _count == _maxSize;
         }
 
         public bool IsEmpty()
         {
             return _count == ;
         }
     }
 }

测试

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace DataStuctureStudy
 {
     class Program
     {
         static void Main(string[] args)
         {
             var queue = new Queues.ArrayQueue<int>();
 
             queue.EnQueue();
             queue.EnQueue();
             queue.EnQueue();
             queue.EnQueue();
             queue.EnQueue();
             while (!queue.IsEmpty())
             {
                 Console.WriteLine(queue.DeQueue());
             }
 
             queue.EnQueue();
             queue.EnQueue();
             queue.EnQueue();
             queue.EnQueue();
             queue.EnQueue();
             while (!queue.IsEmpty())
             {
                 Console.WriteLine(queue.DeQueue());
             }
         }
     }
 }

备注

真正的基于数组的队列还需要考虑扩容，一般的策略是：成本的扩容。