C#排序算法

C排序算法

1. 冒泡排序

N个数字来排队，两两相比小靠前。
外层循环N-1，内层循环N-1-i。

 
int[] list = new int[8] { 8,6,2,7,1,9,0,3}; for (int i = 0; i < list.Length-1; i++)
{
for (int j = 0; j < list.Length-i-1; j++)
{
if (list[j]>list[j+1])
{
  list[j] = list[j + 1]; 
  list[j + 1] = temp;
}

for (int i = 0; i < list.Length; i++)
{
Console.Write(list[i]+"<");
}

2. 简单选择排序

1.从左至右遍历，找到最小(大)的元素，然后与第一个元素交换。
2. 从剩余未排序元素中继续寻找最小（大）元素，然后与第二个元素进行交换。
3. 以此类推，直到所有元素均排序完毕。

    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.插入排序

1.从第一个元素开始，该元素可以认为已经被排序
2.取出下一个元素，在已经排序的元素序列中从后向前扫描
3.如果该元素小于前面的元素（已排序），则依次与前面元素进行比较如果小于则交换，直到找到大于该元素的就则停止；
4.如果该元素大于前面的元素（已排序），则重复步骤2
5.重复步骤2~4 直到所有元素都排好序 。

    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.快速排序

1．i =L; j = R; 将基准数x挖出形成第一个坑a[i]
2．j–由后向前找比基准数小的数，找到后挖出此数填入前一个坑a[i] 中
3．i++由前向后找比基准数大的数，找到后也挖出此数填到前一个坑a[j] 中
4．再重复执行2，3二步，直到i==j，将基准数填入a[i] 中

    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;
    }