C#中队列排序的实践方法

using System.Collections.Generic;

Queue<int> numbers = new Queue<int>();

numbers.Enqueue(1);
numbers.Enqueue(2);
numbers.Enqueue(3);

int firstNumber = numbers.Dequeue();

int firstNumber = numbers.Peek();

numbers.Clear();

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Queue<string> queue = new Queue<string>();
        Console.WriteLine("Initial queue: " + String.Join(", ", queue));

        queue.Enqueue("First");
        queue.Enqueue("Second");
        queue.Enqueue("Third");
        Console.WriteLine("Enqueued elements: " + String.Join(", ", queue));

        string frontElement = queue.Peek();
        Console.WriteLine("Front element: " + frontElement);

        string dequeuedElement = queue.Dequeue();
        Console.WriteLine("Dequeued element: " + dequeuedElement);
        Console.WriteLine("Queue after dequeuing: " + String.Join(", ", queue));
    }
}

Initial queue: 
Enqueued elements: First, Second, Third
Front element: First
Dequeued element: First
Queue after dequeuing: Second, Third

using System;

public class InsertionSortExample
{
    public static void InsertionSort(int[] arr)
    {
        for (int i = 1; i < arr.Length; i++)
        {
            int currentVal = arr[i];
            int j = i - 1;
            // 将arr[i]插入到已排序的序列arr[0...i-1]中
            while (j >= 0 && arr[j] > currentVal)
            {
                arr[j + 1] = arr[j];
                j--;
            }
            // 插入元素
            arr[j + 1] = currentVal;
        }
    }

    public static void Main(string[] args)
    {
        int[] myArray = { 5, 2, 4, 6, 1, 3 };
        InsertionSort(myArray);
        foreach (var element in myArray)
        {
            Console.Write(element + " ");
        }
    }
}

graph TD;
    A[Start] --> B[遍历数组元素]
    B --> C{元素是否已到达数组末尾?}
    C -- 是 --> D[结束排序]
    C -- 否 --> E[取当前元素]
    E --> F[将元素与已排序部分比较]
    F --> G{元素位置找到了吗?}
    G -- 是 --> H[插入元素]
    G -- 否 --> F
    H --> C

using System;
using System.Collections.Generic;

public class PriorityQueue<T> where T : IComparable
{
    private List<T> list = new List<T>();

    public void Enqueue(T item)
    {
        list.Add(item);
        int ci = list.Count - 1; // 新元素的索引
        while (ci > 0)
        {
            int pi = (ci - 1) / 2; // 父节点索引

            if (list[pi].CompareTo(list[ci]) > 0)
            {
                // 交换元素
                T tmp = list[ci];
                list[ci] = list[pi];
                list[pi] = tmp;
                ci = pi;
            }
            else
            {
                break;
            }
        }
    }

    public T Dequeue()
    {
        if (list.Count == 0)
            throw new InvalidOperationException();
        T frontItem = list[0];
        list[0] = list[list.Count - 1];
        list.RemoveAt(list.Count - 1);

        int parentIndex = 0;
        while (parentIndex * 2 + 1 < list.Count)
        {
            int leftChildIndex = parentIndex * 2 + 1;
            int rightChildIndex = leftChildIndex + 1;

            // 找到两个子节点中最小的那个
            int smallerChildIndex = leftChildIndex;
            if (rightChildIndex < list.Count && list[rightChildIndex].CompareTo(list[leftChildIndex]) < 0)
            {
                smallerChildIndex = rightChildIndex;
            }

            // 如果子节点小于父节点，则交换，否则退出循环
            if (list[smallerChildIndex].CompareTo(list[parentIndex]) < 0)
            {
                T tmp = list[parentIndex];
                list[parentIndex] = list[smallerChildIndex];
                list[smallerChildIndex] = tmp;
                parentIndex = smallerChildIndex;
            }
            else
            {
                break;
            }
        }

        return frontItem;
    }
}

class Program
{
    static void Main()
    {
        PriorityQueue<int> priorityQueue = new PriorityQueue<int>();
        priorityQueue.Enqueue(4);
        priorityQueue.Enqueue(2);
        priorityQueue.Enqueue(1);
        priorityQueue.Enqueue(3);

        while (priorityQueue.Count > 0)
        {
            Console.WriteLine(priorityQueue.Dequeue());
        }
    }
}

using System;
using System.Collections.Generic;

public class CustomQueueSorter
{
    // 自定义比较函数，可以根据需要修改逻辑来改变排序规则
    private Comparison<int> _comparison;

    public CustomQueueSorter(Comparison<int> comparison)
    {
        _comparison = comparison;
    }

    // 自定义排序方法
    public int[] Sort(int[] inputArray)
    {
        var queue = new Queue<int>();
        foreach (var item in inputArray)
        {
            queue.Enqueue(item);
        }

        var sortedArray = new List<int>();
        while (queue.Count > 0)
        {
            var current = queue.Dequeue();
            var insertPosition = sortedArray.BinarySearch(current, _comparison);
            // 如果没有找到匹配项，则BinarySearch返回一个负值，指示插入点
            if (insertPosition < 0)
            {
                insertPosition = ~insertPosition;
            }
            sortedArray.Insert(insertPosition, current);
        }

        return sortedArray.ToArray();
    }
}

// 使用示例
class Program
{
    static void Main()
    {
        int[] numbers = { 3, 1, 4, 1, 5, 9, 2, 6, 5 };
        CustomQueueSorter sorter = new CustomQueueSorter((x, y) => y.CompareTo(x)); // 降序排序
        int[] sortedNumbers = sorter.Sort(numbers);

        foreach (var number in sortedNumbers)
        {
            Console.Write(number + " ");
        }
    }
}