c#实现常见算法

#插入排序算法

public static void InsertionSort(int[] array)
{
    int arrayLength = array.Length;//数组长度（时间复杂度为O(n^2)）
    for (int i = 1; i < arrayLength; ++i)
    {
        //定义临时变量
        int temp = array[i];
        int j = i - 1;

        while (j >= 0 && array[j] > temp)
        {
            array[j + 1] = array[j];
            j--;
        }

        array[j + 1] = temp;
    }
}

#快速排序算法

public static void Sort(int[] array, int low, int high)
{
    if (low < high)
    {
        //将数组分割为两部分，并返回分割点的索引
        int pivotIndex = Partition(array, low, high);

        //递归对分割后的两部分进行排序
        Sort(array, low, pivotIndex - 1);
        Sort(array, pivotIndex + 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 - 1; j++)
    {
        //如果当前元素小于等于基准元素，则将它与i+1位置的元素交换
        if (array[j] <= pivot)
        {
            i++;
            Swap(array, i, j);
        }
    }

    //将基准元素放置到正确的位置上
    Swap(array, i + 1, high);

    return i + 1; //返回基准元素的索引
}

private static void Swap(int[] array, int i, int j)
{
    int temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}

#冒泡排序算法

一
     public static void BubbleSort()
 {
     int[] arr = { 1, 8, 9, 5, 6, 2, 3, 4, 7 };
     int arrLength = arr.Length;
     for (int i = 0; i < arrLength - 1; i++)
     {
         for (int j = 0; j < arrLength - i - 1; j++)
         {
             if (arr[j] > arr[j + 1])
             {
                 //交换arr[j]和arr[j+1]的值
                 int temp = arr[j];
                 arr[j] = arr[j + 1];
                 arr[j + 1] = temp;
             }
         }
     }

}

二

public static void RecursiveBubbleSort(int[] arr, int arrLength)
{
    if (arrLength == 1)
        return;

    for (int i = 0; i < arrLength - 1; i++)
    {
        if (arr[i] > arr[i + 1])
        {
            //交换arr[i]和arr[i+1]的值
            int temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
        }
    }

    RecursiveBubbleSort(arr, arrLength - 1);
}

#希尔排序算法

 public static void ShellSort(int[] array)
 {
     int arrLength = array.Length;

     // 初始化增量（初始间隔）为数组长度的一半
     int gap = arrLength / 2;

     // 不断缩小增量，直到增量为1
     while (gap > 0)
     {
         // 对每个子序列进行插入排序
         for (int i = gap; i < arrLength; 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;
         }

         // 缩小增量
         gap /= 2;
     }
 }

#选择排序算法

 static void SelectionSortAlgorithm(int[] arr)
 {
     int n = arr.Length;

     for (int i = 0; i < n - 1; i++)
     {
         // 在未排序部分中找到最小元素的索引
         int minIndex = i;
         for (int j = i + 1; j < n; j++)
         {
             if (arr[j] < arr[minIndex])
             {
                 minIndex = j;
             }
         }

         // 将最小元素与未排序部分的第一个元素交换位置
         int temp = arr[minIndex];
         arr[minIndex] = arr[i];
         arr[i] = temp;
     }
 }