12种排序

---

插入排序

它通过创建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

通常步骤：
1.从第一个元素开始，该元素可以认为已经被排序。
2.取出下一个元素，在已经排序的元素序列中从后向前扫描。
3.如果该元素（已排序）大于新元素，将该元素移到下一位置。
4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置。
5.将新元素插入到该位置后。
6.重复步骤2~5。

void InsertionSort(int[] num, int first, int last)
    {
   
        int i, j;
        int temp;
        for (i = first + 1; i <= last; i++)
        {
   
            temp = num[i];
            j = i - 1;

            //与已排序的数逐一比较，大于temp时，该数后移
            //当first=0，j循环到-1时，由于[[短路求值]]，不会运算array[-1]
            while ((j >= first) && (num[j] > temp))  
            {
   
                num[j + 1] = num[j];
                j--;
            }
            num[j + 1] = temp;      //被排序数放到正确的位置

        }
    }

二分插入排序

它在直接插入排序算法上进行小的改动。它与直接排序算法最大的区别在于查找插入位置时使用的是二分查找的方式，在速度上有一定的提升。

通常步骤：
1.从第一个元素开始，该元素可以认为已经被排序。
2.取出下一个元素，在已经排序的元素序列中二分查找到第一个比它大的数的位置。
3.将新元素插入到该位置后。
4.重复上述两步。

void BinInsertSort(int[] a, int n)
    {
   
        int key, left, right, middle;
        
        for (int i = 1; i < n; i++)
        {
   
            key = a[i];
            left = 0;
            right = i - 1;
            
            while (left <= right)
            {
   
                middle = (left + right) / 2;
                if (a[middle] > key)
                    right = middle - 1;
                else
                    left = middle + 1;
            }

            for (int j = i - 1; j >= left; j--)
            {
   
                a[j + 1] = a[j];
            }
            
            a[left] = key;
        }
    }

---

希尔排序

它也可以称为递减增量排序算法，是插入排序的一种高速而稳定的改进版本。

通常步骤：
1.先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。
2.所有距离为d1的倍数的记录放在同一个组中，在各组内进行直接插入排序。
3.取第二个增量d2<d1重复上述的分组和排序。
4.直至所取的增量dt=1，即所有记录放在同一组中进行直接插入排序为止。

void ShellSort(int[] num)
    {
   
        const int n = num.Length;
        int i, j, temp;
        int gap = 0;
        int[] a = num;
        while (gap <= n)
        {
   
            gap = gap * 3 + 1;
        }
        while (gap > 0)
        {
   
            for (i = gap; i < n; i++)
            {
   
                j = i - gap;
                temp = a[i];
                while ((j >= 0) && (a[j] > temp))
                {
   
                    a[j + gap] = a[j];
                    j = j - gap;
                }
                a[j + gap] = temp;
            }
            gap = (gap - 1) / 3;
        }
    }

---

选择排序

选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

通常步骤：
n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果

1.初始状态：无序区为R[1…n]，有序区为空。
2.第i趟排序开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
3.第n-1趟结束，数组有序化了。

void SelectionSort(int[] a, int len)
    {
   
        int i, j, min, t;
        for (i = 0; i < len - 1; i++)
        {
   
            min = i;
            //查找最小值
            for (j = i + 1; j < len; j++)
                if (a[min] > a[j])
                    min = j;
            //交换
            if (min != i)
            {
   
                t = a[min];
                a[min