C# 中数组的排序算法

在 C# 中，可以对数组进行排序，既可以使用内置排序方法，也可以实现自定义的排序逻辑。以下是对数组排序的详细讨论。

1. 内置排序方法

C# 提供了 Array.Sort 方法和 Array.Reverse 方法，用于对数组进行排序和反转。

1.1 使用默认排序

Array.Sort 默认按照升序排序。

int[] numbers = { 5, 3, 8, 1, 2 };
Array.Sort(numbers); // 默认升序排序
Console.WriteLine(string.Join(", ", numbers)); // 输出: 1, 2, 3, 5, 8

• 适用数据类型： 默认排序适用于实现了 IComparable 接口的类型（如 int, double, string 等）。

1.2 自定义排序

可以通过提供比较器（Comparison<T> 或 IComparer<T>）实现自定义排序逻辑。

• 使用匿名方法或 Lambda 表达式：
• int[] numbers = { 5, 3, 8, 1, 2 }; Array.Sort(numbers, (x, y) => y.CompareTo(x)); // 降序排序 Console.WriteLine(string.Join(", ", numbers)); // 输出: 8, 5, 3, 2, 1
• 通过实现 IComparer<T>：
• class DescendingComparer : IComparer<int> { public int Compare(int x, int y) { return y.CompareTo(x); // 降序 } } int[] numbers = { 5, 3, 8, 1, 2 }; Array.Sort(numbers, new DescendingComparer()); Console.WriteLine(string.Join(", ", numbers)); // 输出: 8, 5, 3, 2, 1

1.3 多维数组排序

多维数组需要先展平为一维数组进行排序，再重新组织为多维数组。

int[,] matrix = { { 3, 2 }, { 5, 1 } };
int[] flatArray = matrix.Cast<int>().ToArray();
Array.Sort(flatArray);

// 重组为多维数组
for (int i = 0, index = 0; i < matrix.GetLength(0); i++)
    for (int j = 0; j < matrix.GetLength(1); j++)
        matrix[i, j] = flatArray[index++];

foreach (var value in matrix) Console.Write(value + " "); // 输出: 1 2 3 5

2. 自定义排序算法

2.1 冒泡排序

适合学习，但在实际应用中效率较低。

int[] numbers = { 5, 3, 8, 1, 2 };
for (int i = 0; i < numbers.Length - 1; i++)
{
    for (int j = 0; j < numbers.Length - i - 1; j++)
    {
        if (numbers[j] > numbers[j + 1])
        {
            int temp = numbers[j];
            numbers[j] = numbers[j + 1];
            numbers[j + 1] = temp;
        }
    }
}
Console.WriteLine(string.Join(", ", numbers)); // 输出: 1, 2, 3, 5, 8

2.2 快速排序

高效的分治算法。

void QuickSort(int[] array, int low, int high)
{
    if (low < high)
    {
        int pivotIndex = Partition(array, low, high);
        QuickSort(array, low, pivotIndex - 1);
        QuickSort(array, pivotIndex + 1, high);
    }
}

int Partition(int[] array, int low, int high)
{
    int pivot = array[high];
    int i = low - 1;
    for (int j = low; j < high; j++)
    {
        if (array[j] < pivot)
        {
            i++;
            (array[i], array[j]) = (array[j], array[i]);
        }
    }
    (array[i + 1], array[high]) = (array[high], array[i + 1]);
    return i + 1;
}

int[] numbers = { 5, 3, 8, 1, 2 };
QuickSort(numbers, 0, numbers.Length - 1);
Console.WriteLine(string.Join(", ", numbers)); // 输出: 1, 2, 3, 5, 8

2.3 插入排序

逐步构建有序数组的排序算法。

int[] numbers = { 5, 3, 8, 1, 2 };
for (int i = 1; i < numbers.Length; i++)
{
    int key = numbers[i];
    int j = i - 1;

    while (j >= 0 && numbers[j] > key)
    {
        numbers[j + 1] = numbers[j];
        j--;
    }
    numbers[j + 1] = key;
}
Console.WriteLine(string.Join(", ", numbers)); // 输出: 1, 2, 3, 5, 8

3. 排序算法比较

4. 内置排序和自定义排序的选择

1. 内置排序：推荐在大多数场景使用，特别是简单数组的排序。性能优秀，简洁可靠。
2. 自定义排序：用于需要特殊排序逻辑的场景，例如复杂对象数组的排序或实现特定的算法要求。可控制排序过程，但开发和维护成本较高。

通过灵活使用内置和自定义排序逻辑，C# 能满足从基本到高级的各种排序需求。