经典排序算法（C#实现）

1. 冒泡排序

    /// <summary>
    /// 冒泡排序
    /// </summary>
    /// <param name="array"></param>
    public static int[] BubbleSort(int[] array)
    {
        for (int i = 0; i < array.Length; i++)
        {
            for (int j = 0; j < array.Length - i - 1; j++)
            {
                if (array[j] > array[j + 1])
                {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        return array;
    }
        

2. 简单选择排序

    /// <summary>
    /// 选择排序
    /// 
    /// 1. 从左至右遍历，找到最小(大)的元素，然后与第一个元素交换。
    /// 2. 从剩余未排序元素中继续寻找最小（大）元素，然后与第二个元素进行交换。
    /// 3. 以此类推，直到所有元素均排序完毕。
    /// </summary>
    /// <param name="array"></param>
    public static int[] SelectionSort(int[] array)
    {
        for (int i = 0; i < array.Length; i++)
        {
            int min = i;

            // 从i+1个元素开始，找最小值的下标
            for (int j = i + 1; j < array.Length; j++)
            {
                if (array[min] > array[j])
                    min = j;
            }

            // 交换元素
            int temp = array[i];
            array[i] = array[min];
            array[min] = temp;
        }
        return array;
    }
        

3.插入排序

    /// <summary>
    /// 插入排序
    /// 
    /// 1.从第一个元素开始，该元素可以认为已经被排序
    /// 2.取出下一个元素，在已经排序的元素序列中从后向前扫描
    /// 3.如果该元素小于前面的元素（已排序），则依次与前面元素进行比较如果小于则交换，直到找到大于该元素的就则停止；
    /// 4.如果该元素大于前面的元素（已排序），则重复步骤2
    /// 5.重复步骤2~4 直到所有元素都排好序 。
    /// </summary>
    /// <param name="array"></param>
    /// <returns></returns>
    public static int[] InsertSort(int[] array)
    {
        int length = array.Length;
        //从第二个元素开始
        for (int i = 1; i < length; i++)
        {
            //从第i个元素开始，一次和前面已经排好序的i-1个元素比较，如果小于，则交换
            for (int j = i; j > 0; j--)
            {
                if (array[j] < array[j - 1])
                {
                    int temp = array[j];
                    array[j] = array[j - 1];
                    array[j - 1] = temp;
                }
                //如果大于，则不用继续往前比较了，因为前面的元素已经排好序，比较大的大就是大的了。
                else
                    break;
            }
        }
        return array;
    }

4.快速排序

    /// <summary>
    /// 快速排序
    /// 
    /// 1．i =L; j = R; 将基准数x挖出形成第一个坑a[i]
    /// 2．j--由后向前找比基准数小的数，找到后挖出此数填入前一个坑a[i] 中
    /// 3．i++由前向后找比基准数大的数，找到后也挖出此数填到前一个坑a[j] 中
    /// 4．再重复执行2，3二步，直到i==j，将基准数填入a[i] 中
    /// </summary>
    /// <param name="array"></param>
    /// <returns></returns>
    public static int[] QuickSort(int[] array, int left, int right)
    {
        if (left < right)
        {
            int i = left, j = right;
            int x = array[i];
            while (i < j)
            {
                // i填j的坑，j填i的坑

                // 从右往左找，找小于基准的数，如果该数大于等于基准，j-- 继续找
                while (i < j && array[j] >= x)
                {
                    j--;
                }
                if (i < j)
                {
                    array[i] = array[j];  // 将array[j]填入array[i]中，array[j]就形成一个新坑
                    i++;
                }

                // 从左往右找，找大于基准的数，如果该数小于基准，i++ 继续找
                while (i < j && array[i] < x)
                {
                    i++;
                }
                if (i < j)
                {
                    array[j] = array[i];
                    j--;
                }

            }
            // 退出时，i=j，将x填入该坑
            array[i] = x;
            QuickSort(array, left, i - 1);
            QuickSort(array, i + 1, right);
        }

        return array;
    }

END