优先级队列（小顶堆）

using System;
using System.Collections.Generic;

namespace Utils
{
    public class PriorityQueue<T> where T : IComparable<T>
    {
        public List<T> list = null;
        public int Count { get => list.Count; }
        /// 

        /// 进队列
        /// 
        /// 
        public PriorityQueue(int capacity = 4) {
            list = new List<T>(capacity);
        }
        /// 

        /// 出队列
        /// 
        /// 
        public void Enqueue(T item) {
            list.Add(item);
            HeapfiyUp(Count - 1);
        }
        public T Dequeue() {
            if (Count == 0) {
                return default(T);
            }
            T value = list [0];
            int endIndex = Count - 1;
            list [0] = list [endIndex];
            list.RemoveAt(endIndex);
            --endIndex;

            HeapfiyDown(0 , endIndex);
            return value;
        }
        public T Peek() {
            return Count > 0 ? list [0] : default;
        }
        public int IndexOf(T item) {
            return list.IndexOf(item);
        }
        public T RemoveAt(int index) {
            if (Count < index) 
                return default;
            T item = list [index];
            int endIndex = Count - 1;
            list [index] = list [endIndex];
            list.RemoveAt(endIndex);
            --index;
            if (index<endIndex) {
                int parentIndex = (index - 1) / 2;
                if (parentIndex > 0 && list [index].CompareTo(list [index]) < 0) {
                    HeapfiyUp(index);
                }
                else {
                    HeapfiyDown(index , endIndex);
                }
            }
            return item;
        }
        public T RemoveItem(T item) {
            int index = IndexOf(item);
            return index != -1 ? RemoveAt(index) : default;
        }
        public void Clear() {
            list.Clear();
        }
        public bool Contains(T item) {
            return Count > 0 ? list.Contains(item) : false;
        }
        public bool IsEmpty() {
            return Count == 0;
        }
        public List<T> ToList() {
            return list;
        }
        public T [] ToArray() {
            return list.ToArray();
        }
        private void Swap(int a , int b) {
            T temp = list [a];
            list [a] = list [b];
            list [b] = temp;
        }
        private void HeapfiyUp(int childIndex) {
            int parentIndex = (childIndex - 1) / 2;
            while (childIndex > 0 && list [childIndex].CompareTo(list [parentIndex]) < 0) {
                Swap(childIndex , parentIndex);
                childIndex = parentIndex;
                parentIndex = (childIndex - 1) / 2;
            }
        }
        private void HeapfiyDown(int topIndex,int endIndex) {
            while (true) {
                int minIndex = topIndex;
                int childIndex = topIndex * 2 + 1;
                //left
                if (childIndex <= endIndex && list [childIndex].CompareTo(list [topIndex]) < 0) 
                    minIndex = childIndex;
                //right
                childIndex = topIndex * 2 + 2;
                if (childIndex <= endIndex && list [childIndex].CompareTo(list [minIndex]) < 0) 
                    minIndex = childIndex;
                if (topIndex == minIndex) {
                    break;
                }
                Swap(topIndex , minIndex);
                topIndex = minIndex;
            }
        }
    }
}

使用方法：

    public class Item : IComparable<Item>
    {
        public string itemName;
        public float priority;
        public int CompareTo(Item other) {
            if (priority<other.priority) {
                return -1;
            }
            else if (priority > other.priority) {
                return 1;
            }
            return 0;
        }

        public void Print() {
            Console.WriteLine($"itemName:{itemName}--priority:{priority}");
        }
    }

class Example
    {
        static void Main(string [] args) {
            Item item1 = new Item { itemName = "1" , priority = 666 };
            Item item2 = new Item { itemName = "2" , priority = 6 };
            Item item3 = new Item { itemName = "3" , priority = 6666 };
            Item item4 = new Item { itemName = "4" , priority = 66 };
            Item item5 = new Item { itemName = "5" , priority = 66666 };

            Queue<Item> queue = new Queue<Item>();
            queue.Enqueue(item1);
            queue.Enqueue(item2);
            queue.Enqueue(item3);
            queue.Enqueue(item4);
            queue.Enqueue(item5);
            while (queue.Count > 0) {
                Item item = queue.Dequeue();
                item.Print();
            }
            Console.WriteLine("------------------------");
            PriorityQueue<Item> priorityQueue = new PriorityQueue<Item>();
            priorityQueue.Enqueue(item1);
            priorityQueue.Enqueue(item2);
            priorityQueue.Enqueue(item3);
            priorityQueue.Enqueue(item4);
            priorityQueue.Enqueue(item5);
            while (priorityQueue.Count > 0) {
                Item item = priorityQueue.Dequeue();
                item.Print();
            }
            Console.ReadKey();
        }
    }

大顶推只需将54行、89行、100行以及104行的<0 改成>0即可