算法：优先级队列（PriorityQueue）

背景

此文给出基于已排序数组的实现，多数情况应该基于 Heap 进行实现，因为数组的插入效率为O(n)，而 Heap 的插入效率为 Log(n)。

PriorityQueue

代码

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;

 namespace DataStuctureStudy.Queues
 {
     public class PriorityQueue<T>
         where T : IComparable<T>
     {
         private readonly int _maxSize;
         private readonly T[] _items;
         private int _count = ;
         private int _head = -;

         public PriorityQueue(int size)
         {
             _maxSize = size;
             _items = new T[size];
         }

         public void EnQueue(T item)
         {
             if (this.IsFull())
             {
                 throw new InvalidOperationException("队列已满");
             }

             if (_count == )
             {
                 _items[++_head] = item;
             }
             else
             {
                 _items[++_head] = item;
                 for (var i = _head; i >= ; i++)
                 {
                     if (_items[i].CompareTo(item) < )
                     {
                         Swap(_items, i - , i);
                     }
                     else
                     {
                         break;
                     }
                 }
             }

             _count++;
         }

         public T DeQueue()
         {
             if (this.IsEmpty())
             {
                 throw new InvalidOperationException("队列已空");
             }

             T item = _items[_head--];

             _count--;

             return item;
         }

         public T Peek()
         {
             if (this.IsEmpty())
             {
                 throw new InvalidOperationException("队列已空");
             }

             return _items[_head];
         }

         public bool IsFull()
         {
             return _count == _maxSize;
         }

         public bool IsEmpty()
         {
             return _count == ;
         }

         public int Size()
         {
             return _count;
         }

         private static void Swap(T[] items, int left, int right)
         {
             if (left != right)
             {
                 var temp = items[left];
                 items[left] = items[right];
                 items[right] = temp;
             }
         }
     }
 }