.Net中的优先级队列

优先级队列（Priority Queue）是计算机科学中的一种数据结构，它允许在队列中的元素根据优先级进行排列。优先级队列通常用于实现调度算法和操作系统中的任务管理。在.NET中，优先级队列主要有两种实现方式，即GenericPriorityQueue和PriorityQueue。下面来详细讲解这两种实现方式。

GenericPriorityQueue（泛型优先级队列）

GenericPriorityQueue是一个基于泛型实现的优先级队列。它采用IComparer<T>来定义队列中元素的比较方式，以及Heap<TKey, TValue>来表示优先级队列。

主要特点：

多态：支持各种泛型类型。
比较器：使用IComparer<T>，定义了队列中元素的比较方式。
快速插入：采用二分插入，时间复杂度为O(log n)。
快速删除：采用二叉树合并，时间复杂度为O(log n)。
高效查找：通过二叉搜索树实现，时间复杂度为O(log n)。

public class MyPriorityQueue<T> : Heap<int, T> where T : IComparable<T>
{
    public MyPriorityQueue()
        : base(0, true)
    {
    }

    public static void Push(MyPriorityQueue<T> stack, T item)
    {
        if (stack.Count < 1000)
        {
            stack.Comparer = Comparer<T>.Create((item1, item2) => item1.CompareTo(item2));
            stack.Add((item));
        }
    }

    public static void Pop(MyPriorityQueue<T> stack, int lastOrDefault)
    {
        if (stack.Count == 0)
            throw new ArgumentException("Queue has no elements");

        int firstOrDefault;
        if (stack.Count <= lastOrDefault)
        {
            firstOrDefault = lastOrDefault;
            lastOrDefault = 0;
        }
        else
        {
            foreach (var item in stack)
                if (item.CompareTo(stack.Comparer.CompareKeys(stack.Count - 1, 0)[1]) > EqualKey)
                    lastOrDefault = Math.Max(lastOrDefault, item.Key);
            firstOrDefault = 0;
        }

        stack.RemoveAt(FirstGreaterIndex(lastOrDefault) ? FirstGreaterIndex(lastOrDefault)
                                                                 : LastGreaterIndex(stack.Comparer.CompareKeys(stack.Count - 2, 0)[0]));
    }
}

PriorityQueue<T>(泛型优先级队列)

PriorityQueue是一个基于结构体的优先级队列，它使用对象进行插入和删除操作。它实现了Heap<TKey, TValue>接口，表示优先级队列。

主要特点：

单根优先级树：通过二叉搜索树来实现，所有元素都按升序排列。
优先级规则：直接使用对象进行插入和删除操作，定义了队列元素的优先级。

public class PriorityQueue<T> : Heap<int, T>
{
    public PriorityQueue(T item, IComparer<T> comparer)
    {
        Comparer = comparer;
        Insert(item);
    }

    public static PriorityQueue<T> BuildHeap<T>(IEnumerable<T> nums)
        where T : IComparable<T>
    {
        return nums.OrderBy(item => item, Comparer<T>.Create((item1, item2) => item1.CompareTo(item2))).Reverse().ToDynamicPriorityQueue<T>();
    }

    public static T Peek<T>(dynamic queue)
    {
        var index = ((dynamic)queue).Count - 1;
        return ((dynamic)queue)[index];
    }

    public static int Count<T>(dynamic queue)
        where T : IComparable<T>
    {
        return ((dynamic)queue).Count - 1;
    }

    public static void ConsumeAndPush<T>(dynamic queue, List<T> consumedItems)
        where T : IComparable<T>
    {
        var index = ((dynamic)queue).Count - 1;

        while (index >= 0 && 
               consumedItems.Contains(((dynamic)queue)[index], Enumerable.Comparer<T>()))
            index--;

        Consumed.Swap(queue, index, queue.Count - 1);
        queue.RemoveRange(queue.Count - 1, stack.Count - minHeapCount);
        Swap(queue, queue.Count - minHeapCount, minHeapCount);
        minHeapCount++;
        Push(queue, NextLowest(queue.[queue.Count - minHeapCount]));

        for (var i = consumedItems.Count - 1; i >= 0; i--)
        {
            if (!queue.Contains(consumedItems[i], 
                                  queue.Comparer as IComparer<int>))
            )
                 queue.Push(consumedItems[i]);
            else
                index++;
            
            if (i != 0 && queue.Contains(