内部排序（一）插入排序

插入排序分为4种：

直接插入排序、折半插入排序、2-路插入排序、表插入排序、希尔排序。

下面我们来一一介绍：

直接插入排序

注意：
1. 插入成功一个值为一趟。
2. 需要在r[0]处设置监视哨。
3. 整个排序过程进行n-1趟插入。

算法程序：

void InsertSort(SqList &L){
    //对顺序表L做直接插入排序(升序)
    for(i=2;i<=L.length;i++){
        if( L.r[i].key < L.r[i-1].key ){
            L.r[0]=L.r[i];//设置监视哨
            L.r[i]=L.r[i-1];//对r[i-1]进行后移
            for(j=i-2; L.r[0].key < L.r[j].key ;j--){
            //因为第一个if语句已经判断过r[i-1]和r[i](哨兵)的大
            //小，并进行后移操作，故此处从r[i-2]开始。j中最后存放要
            //插入点的下标。

                L.r[j+1]=L.r[j];//不符合条件，后移。
            }
            L.r[j+1]=L.r[0];//进行插入
        }
    }
}

评价：

1.直接插入排序比较次数和移动次数约为(n^2)/4时间复杂度为O（x^2）.
2.适用于n很小的情况。

折半插入排序

折半查找原理很简单，就是把直接插入排序过程中的直接查找过程用二分查找代替，即减少比较次数。
算法代码：

void BInsertSort(SqList &L){
//对顺序表L作折半插入排序。
    for(i=2;i<=L.length;i++){//将r[i]插入到r[i~(i-1)]的有序序列中
        L.r[0]=L.r[i];//设置监视哨
        low=1;
        high=i-1;
        while(low<=high){//找出插入点
            m=(low+high)/2;
            if( L.r[0].key < L.r[m].key){
                high=m-1;
            }else{
                low=m+1;
            }
        }

        for(j=i-1;j>=high+1;j--){
            L.r[j+1]=L.r[j];//记录后移
        }

        L.r[high+1]=L.r[0];//插入
    }
}

评价：

1.折半插入排序仅减少了比较次数，而记录的移动次数不便。故时间复杂度依然为O(x^2)。
2.适用于n比较大时。

2-路插入排序

原理：
2-路插入排序是在折半插入排序的基础上再改进，目的是减少排序过程中移动记录的次数。为此需要n个记录的辅助空间。

过程叙述：
另设置一个和L.r同类型的数组d，首先将L.r[1]赋值给d[1],并将d[1]看成是在排好序的序列中处于中间位置的记录，然后从L.r中第二个记录起依次插入到d[1]之前或之后的有序序列中。
通过一个辅助的循环数组, 如果大于最大的元素, 则插入至尾部, 如果小于最小的元素, 则插入至头部,
如果在两者之间, 采用折半查找的方式,移动一部分的元素;
演示

注意：

1. 把d看成一个循环数组。（所谓的循环数组并不是指它们真的首尾相接，而是指逻辑上循环。通过%完成）
   用(x+n)%n取代x，即可完成循环。
2. 设置两个指针first和final分别指示排序过程中得到的有序序列中的第一个记录和最后一个记录在d中的位置。

算法程序：

void TwoRoadInsertSort(int *arr, int *temp, int n)  {
//arr为原数组，temp为临时数组，n为数组长度

    int i, first, final, k;  

    first = final = 0;  
    temp[0] = arr[0];//将arr首元素赋给temp  

    for (i = 1; i < n; i ++) {  
        if (arr[i] < temp[first]) {  // 待插入元素比最小的元素小  
            first = (first - 1 + n) % n;  
            temp[first] = arr[i];  
        } else if (arr[i] > temp[final]) { // 待插入元素比最大元素大  
            final = (final + 1 + n) % n;  
            temp[final] = arr[i];  
        } else { // 插入元素比最小大，比最大小（此过程可自己在上面演示中最后添加元素26，走一遍）note：此处最好用折半查找！！！  
            k = (final + 1 + n) % n;  
            while (temp[((k - 1) + n) % n] > arr[i]) {  
                temp[(k + n) % n] =temp[(k - 1 + n) % n];  
                k = (k - 1 + n) % n;  
            }  
            temp[(k + n) % n] = arr[i];  
            final = (fianl + 1 + n) % n;  
        }  
    }  

    // 将排序记录复制到原来的顺序表里  
    for (k = 0; k < n; k ++) {  
        arr[k] = temp[(first + k) % n];  
    }  
}  

评价：

2-路插入排序首尾插入不需要移动元素。移动次数约为(n^2)/8，可以减少移动次数，并不能避免移动。

表插入排序

引入背景：在2-路插入排序的基础上再减少移动次数，直至不需要移动。
（未完待续……）