分享一个自己写的简单的最大优先队列。解决思路

    public sealed class PriorityQueue<T> where T : IComparable<T>
    {
        private T[] heap;
        public int Count { get; private set; }

        public PriorityQueue(int capacity) 
        {
            if (capacity <= 0)
            {
                throw new InvalidOperationException("优先队列的初始容量必须大于0");
            }
            heap = new T[capacity];
        }

        public PriorityQueue()
            : this(32)
        { }

        public PriorityQueue(T[] array)
        {
            Count = array.Length;
            heap = array;
            BuildMaxHeap(heap);
        }

        /// <summary>
        /// 获取优先级最高的元素
        /// </summary>
        /// <returns></returns>
        public T Top()
        {
            ThrowExceptionIfPriorityQueueIsNull();

            return heap[0];
        }

        /// <summary>
        /// 删除并返回优先级最高的元素
        /// </summary>
        /// <returns></returns>
        public T ExtractTop()
        {
            ThrowExceptionIfPriorityQueueIsNull();

            T top = heap[0];
            heap[0] = heap[this.Count - 1];
            heap[this.Count - 1] = default(T);
            this.Count--;
            //保持堆的性质
            HeapifyDown(0);

            return top;
        }

        private void ThrowExceptionIfPriorityQueueIsNull()
        {
            if (Count <= 0)
                throw new InvalidOperationException("优先队列为空");
        }

        /// <summary>
        /// 增加索引位置元素的优先级
        /// </summary>
        /// <param name="index">当前元素的索引</param>
        /// <param name="newValue">新的优先级元素</param>
        public void IncreasePriority(int index, T newValue)
        {
            if (index < 0 || index >= Count)
            {
                throw new IndexOutOfRangeException("当前索引超出队列范围");
            }

            if (newValue.CompareTo(heap[index]) < 0)
            {
                throw new InvalidOperationException("新值必须大于当前值");
            }

            heap[index] = newValue;
            HeapifyUp(index);
        }

        /// <summary>
        /// 从指定位置向下调整堆，保证堆的性质
        /// </summary>
        /// <param name="current"></param>
        private void HeapifyDown(int current)
        {
            //当前元素的左子元素的索引
            int left = (current + 1) * 2 - 1;
            //当前元素的右子元素的索引
            int right = left + 1;
            int largest;

            if (left < Count && heap[left].CompareTo(heap[current]) > 0)
            {
                largest = left;
            }
            else
            {
                largest = current;
            }

            if (right < Count && heap[right].CompareTo(heap[largest]) > 0)
            {
                largest = right;
            }

            //如果单前值得优先级不为最高，则继续向下调整
            if (largest != current)
            {
                Swap(ref heap[current], ref heap[largest]);
                HeapifyDown(largest);
            }
        }

        /// <summary>
        /// 给优先队列添加新的元素
        /// </summary>
        /// <param name="key"></param>
        public void Insert(T key)
        {
            if (Count == heap.Length)
            {
                EnsureCapacity(Count);
            }

            heap[Count++] = key;
            HeapifyUp(Count - 1);
        }

        /// <summary>
        /// 将数组调整为最大堆
        /// </summary>
        /// <param name="array"></param>
        private void BuildMaxHeap(T[] array)
        {
            int count = array.Length / 2 - 1;
            for (; count >= 0; count--)
            {
                HeapifyDown(count);
            }
        }

        private void EnsureCapacity(int min)
        {
            int num = min * 2;
            T[] detisnationArray = new T[num];
            Array.Copy(this.heap, detisnationArray, heap.Length);
            heap = detisnationArray;
        }

        private static void Swap(ref T value1, ref T value2)
        {
            T temp = value1;
            value1 = value2;
            value2 = temp;
        }

        /// <summary>
        /// 从指定位置开始向上调整，保证堆的性质
        /// </summary>
        /// <param name="current"></param>
        private void HeapifyUp(int current)
        {
            //当前元素的父元素
            int parent = (current - 1) / 2;
            while (current > 0 && heap[parent].CompareTo(heap[current]) < 0)
            {
                Swap(ref heap[parent],ref heap[current]);
                current = (current - 1) / 2;
                parent = (parent - 1) / 2;
            }
        }
    }