从0开始复健——算法之内部排序和增小缩量排序

基于顺序比较的简单排序算法

插入排序（Insertion Sort）

1. 直接插入排序
2. 折半插入排序
3. 表插入排序
   冒泡排序（Bubble Sort）

直接插入排序：设有n个记录，存放在数组r中，重新安排记录在数组中的存放顺序，使得按关键码有序。即
r[1].key<=r[2].key<=…<=r[n].key;
直接插入排序方法：仅有一个记录的表总是有序的，因此，对n个记录的表，可从第二个记录开始直到第n个记录，逐个向有序表中插入，从而得到n个记录按关键码有序的表。
直接插入排序的时间复杂度为O（n²），并且是一个稳定的排序方法。

    public static void insertionSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int j = i;
            while (j > 0 && arr[j] < arr[j - 1]) {
                swap(arr,j,j-1);
                j--;
            }
        }
    }

折半插入排序：
思想：不断二分有序表来确定插入位置，即一次比较，通过待插入记录与有序表居中的记录按关键码比较，将有序表一分为二，然后一直重复上述操作。当最后的子表只有一个记录的时候，便确定了插入的位置。

void binary_insertion_sort(int arr[], int len) 
{
        int i, j, temp, m, low, high;
        for (i = 1; i < len; i++)
        {
               temp = arr[i];
               low = 0; high = i-1;
               while (low <= high)
               {
                      m = (low +high) / 2;
                      if(arr[m] > temp)
                               high = m-1;
                      else
                               low = m+1;
               }
         }
         for (j = i-1; j>=high+1; j--)
               arr[j+1] = arr[j];
         arr[j+1] = temp;
}

冒泡排序：对于n个记录的表，第一趟冒泡得到一个关键码最大的记录r[n]，第二趟对n-1个记录进行冒泡排序，再得到一个关键码最大的记录r[n-1]，重复上述操作，直到得到n个记录按关键码有序的表。

    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            boolean flag = true;//设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已然完成。
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr,j,j+1);
                    flag = false;
                }
            }
            if (flag) {
                break;
            }
        }
    }

缩小增量排序方法——希尔排序（Sheel Sort）

希尔排序：又称增小缩量排序。思路：选择步长，按步长序列个数k，对序列进行k趟排序。

void shellSort(myDataType *ary,int len)
{
    int i,j;
    int increment = len;//增量
    myDataType key;
    while(increment > 1)//最后在增量为1并且是执行了情况下停止。
    {
        increment = increment/3 + 1;//根据公式
        //printf("increment:%d\n",increment);
        for (i=increment;i<len;i++)//从[0]开始，对相距增量步长的元素集合进行修改。
        {
            key = ary[i];
            //以下和直接插入排序类似。
            j=i-increment;
            while(j >= 0)
            {
                if (key < ary[j] )
                {
                    myDataType temp = ary[j];
                    ary[j] = key;
                    ary[j+increment] = temp;
                }
                j=j-increment;
            }
        }
    }
}