C#几种常见的排序方式

1.冒泡排序

原理：比较两个相邻的元素，将其中大的一个元素移到后方，这样第一轮比较完成后，最大的元素就排到了元素的末尾

通过几轮的比较就可以将 所有的元素进行从大到小的排序

我们假定有一个数组 int[] arr={100,30,50,200,60,79,-10,-50,0};

第一轮比较100和30，如果左边的元素大于右边的元素，则交换

比较的结果是30 100，以此类推100 和50 比较 结果是 50 100

第一轮的比较结果是 30，50，100，60，79，-10，-50，0，200

这样最大的元素就跑到了后面，所以第二轮的比较最后一个元素就不用比较了

第二轮比较索引还是从0开始，只是最后一个不用比较，算法还是一样的

 

所谓冒泡排序就是指：将一个数组中的元素按照从大到小或者从小到大的顺序进行排列。

 

int[] nums = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
第一趟比较：8 7 6 5 4 3 2 1 0 9 交换了9次     i=0  j=nums.Length-1-i
第二趟比较：7 6 5 4 3 2 1 0 8 9 交换了8次     i=1  j=nums.Length-1-i
第三趟比较：6 5 4 3 2 1 0 7 8 9 交换了7次     i=2  j=nums.Length-1-i
第四趟比较：5 4 3 2 1 0 6 7 8 9 交换了6次     i=3  j=nums.Length-1-i
第五趟比较：4 3 2 1 0 5 6 7 8 9 交换了5次     依次类推
第六趟比较：3 2 1 0 4 5 6 7 8 9 交换了4次     。。。
第七趟比较：2 1 0 3 4 5 6 7 8 9 交换了3次     。。。
第八趟比较：1 0 2 3 4 5 6 7 8 9 交换了2次  。。。
第九趟比较：0 1 2 3 4 5 6 7 8 9 交换了1次     i=8  j=nums.Length-1-i

 

排序结果是：0,1,2,3,4,5,6,7,8,9

 

2.选则排序

 

选择排序是从冒泡排序演化而来的，每一轮比较得出最小的那个值，然后依次和每轮比较的第一个值进行交换。
目的：按从小到大排序。
方法：假设存在数组：72, 54, 59, 30, 31, 78, 2, 77, 82, 72
第一轮依次比较相邻两个元素，将最小的一个元素的索引和值记录下来，然后和第一个元素进行交换。
如上面的数组中，首先比较的是72,54，记录比较小的索引是54的索引1。接着比较54和59，比较小的索引还是1。直到最后得到最小的索引是2的索引6，然后索引6和0互相交换。

第二轮比较的时候是最小的一个元素和索引1进行交换。第三轮、第四轮以此类推。

具体代码如下

 

3.插入排序

比如有一列数组 5 2 4 6 3 5

从第二个数开始遍历，先定义一个临时的Key去保存这个数 ,和它前一个数的索引i

当i = j-1>=0；这个索引在数组中存在时，且 list[i]>key时

就这list [i+1] = list [i]; 就把前一个数往后挪一位，

i-- 继续寻找前面是否还有数，也是循环的条件

当跳出循环时：把key值插入到指定的位置中

 

还有面试题中经常出现的快速排序，它采用的是一种分治的思想（取一个数作为基准数，比它小的数都放左边，比它大的数都放右边）

我们先用百度里的一张图来解释

 

具体实现的代码如下

using System;

namespace MyQuickSort
{
    class Program
    {
        static void Main(string[] args)
        {
            
        }
        /// <summary>
        /// 对数组进行一次单元排序
        /// </summary>
        /// <param name="arr">要排序的数组</param>
        /// <param name="low">起始位置</param>
        /// <param name="high">结束位置</param>
        /// <returns></returns>
        public static int UnitQuicksort(int[] arr,int low,int high)
        {   
            //取第一个数作为基准数
            int key = arr[low];
            while (low<=high)
            {
                //从后往前找比key小的数
                while (arr[high]>key&&high>low)
                {
                    high--;
                }
                //交换位置
                arr[low] = arr[high];
                //从前往后找比key大的数
                while (arr[low]<key&&low<high)
                {
                    low++;
                }
                arr[high] = arr[low];
            }
            //low = high 结束单元排序，把key值放入
            arr[low] = key;
            return high;
        }

        public static void QuickSort(int[] arr, int low, int high)         {             if (low >= high) return;             //进行一次单元排序             int index = UnitQuicksort(arr, low, high);             //对左边进行单元排序             QuickSort(arr, low, index - 1);             //对右边进行单元排序             QuickSort(arr, index + 1, high);         }     }      }