用C#实现常用的七大排序算法

1. 冒泡排序（Bubble Sort）

2. 选择排序（Selection Sort）

3. 插入排序（Insertion Sort）

4. 希尔排序（Shell Sort）

5. 归并排序（Merge Sort）

6. 快速排序（Quick Sort）

7. 堆排序（Heap Sort）

1.冒泡排序（Bubble Sort）：依次比较相邻的两个元素，将较大的元素向后移动，直到没有相邻元素需要交换为止。 

public static void BubbleSort(int[] array)
{
    int n = array.Length;
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j < n - i - 1; j++)
        {
            if (array[j] > array[j + 1])
            {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

2.选择排序（Selection Sort）：每次从未排序的部分选取最小（或最大）的元素，放到已排序部分的末尾。

public static void SelectionSort(int[] array)
{
    int n = array.Length;
    for (int i = 0; i < n - 1; i++)
    {
        int minIndex = i;
        for (int j = i + 1; j < n; j++)
        {
            if (array[j] < array[minIndex])
            {
                minIndex = j;
            }
        }
        int temp = array[minIndex];
        array[minIndex] = array[i];
        array[i] = temp;
    }
}

3.插入排序（Insertion Sort）：将未排序的元素逐个插入到已排序部分的正确位置。

public static void InsertionSort(int[] array)
{
    int n = array.Length;
    for (int i = 1; i < n; ++i)
    {
        int key = array[i];
        int j = i - 1;
        while (j >= 0 && array[j] > key)
        {
            array[j + 1] = array[j];
            j = j - 1;
        }
        array[j + 1] = key;
    }
}

4.希尔排序（Shell Sort）：改进的插入排序，通过将数组分成多个子序列进行排序，最终使数组成为有序。

public static void ShellSort(int[] array)
{
    int n = array.Length;
    for (int gap = n / 2; gap > 0; gap /= 2)
    {
        for (int i = gap; i < n; i++)
        {
            int temp = array[i];
            int j = i;
            while (j >= gap && array[j - gap] > temp)
            {
                array[j] = array[j - gap];
                j -= gap;
            }
            array[j] = temp;
        }
    }
}

5.归并排序（Merge Sort）：将数组分成两个子数组，分别排序，然后合并两个已排序的子数组。

public static void MergeSort(int[] array, int left, int right)
{
    if (left < right)
    {
        int mid = (left + right) / 2;
        MergeSort(array, left, mid);
        MergeSort(array, mid + 1, right);
        Merge(array, left, mid, right);
    }
}

private static void Merge(int[] array, int left, int mid, int right)
{
    int n1 = mid - left + 1;
    int n2 = right - mid;

    int[] L = new int[n1];
    int[] R = new int[n2];

    for (int i = 0; i < n1; ++i)
    {
        L[i] = array[left + i];
    }
    for (int j = 0; j < n2; ++j)
    {
        R[j] = array[mid + 1 + j];
    }

    int k = left;
    int p = 0, q = 0;
    while (p < n1 && q < n2)
    {
        if (L[p] <= R[q])
        {
            array[k] = L[p];
            p++;
        }
        else
        {
            array[k] = R[q];
            q++;
        }
        k++;
    }

    while (p < n1)
    {
        array[k] = L[p];
        p++;
        k++;
    }

    while (q < n2)
    {
        array[k] = R[q];
        q++;
        k++;
    }
}

6.快速排序（Quick Sort）：选择一个基准元素，将数组分成两个子数组，小于基准的放在左边，大于基准的放在右边，然后对子数组递归地进行排序。

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

private static 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++;
            int temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }
    int temp1 = array[i + 1];
    array[i + 1] = array[high];
    array[high] = temp1;
    return i + 1;
}

7.堆排序（Heap Sort）：利用堆这种数据结构进行排序。先将数组构建成最大堆，然后依次将堆顶元素与最后一个元素交换，并重新调整堆，直到所有元素都排好序。

public static void HeapSort(int[] array)
{
    int n = array.Length;
    for (int i = n / 2 - 1; i >= 0; i--)
    {
        Heapify(array, n, i);
    }
    for (int i = n - 1; i >= 0;