内部排序->插入排序->其它插入排序->2-路插入排序

文字描述

　　在折半插入排序的基础上进行改进, 另设一个和待排序序列L相同的数组D, 首先将L[1]赋值给D[0]， 数组D中数据是已经排好序的， first指向最小值下标，final指向最大值下标。初始时，first和final值都为0。之后将L的第二个元素开始依次和D[0]比较，大于D[0]的插入到D[0]之后的序列，小于D[0]的插入到D[0]之前的序列；这里可以将数组D想象成一个循环的圆。

示意图

 

算法分析

　　时间复杂度为n*n, 辅助空间为n，是稳定的排序方法。 

　　二路插入排序和折半插入排序比，只是可以大概率的减少移动的次数，但不能绝对避免，当待排序序列中的第一个数据就是最小值或者最大值时，2-路插入排序将完全失去它的优越性。

 

代码实现

#include <stdio.h>
#include <stdlib.h>

#define EQ(a, b) ((a) == (b))    //数a和数b相等则为True,否则为False
#define LT(a, b) ((a) <  (b))    //数a小于数b则为True
#define LQ(a, b) ((a) <= (b))    //数a小于或等于数b则为True

#define MAXSIZE 20    //待排序数的最多个数
typedef int KeyType;    //定义待排序数据的关键字类型为int
typedef int InfoType;    //定义待排序数据的其他信息类型为int
typedef struct{
    KeyType key;        //关键字
    InfoType otherinfo;    //其他数据项
}RedType;    //记录类型

typedef struct{
    RedType r[MAXSIZE+1];    //r[0]闲置或用作哨兵单元
    int length;    //顺序表长度
}SqList;    //顺序表类型

/*
 * 顺序打印序列表L中的关键字
 */
void PrintList(SqList L){
    int i = 0;
    printf("len:%d; data:", L.length);
    for(i=1; i<=L.length; i++){
        printf("%d ", L.r[i].key);
    }
    printf("\n");
    return ;
}

#define DEBUG 

/*
 * 2-路插入排序算法的实现
 *
 * @param 
 *        SqList *L : 待排序的顺序表
 */
void TwoInsertSort(SqList *L)
{
    //数组D是和L中关键字列表长度相同的辅助数组
    RedType D[MAXSIZE] = {0};
    //将L中第一个数据存入D[0]
    D[0] = L->r[1];

    int i = 0, j = 0, n = L->length;
    //first表示D中最小值下标，final表示D中最大值下标
    int first = 0, final = 0;
    int k = 0;
#ifdef DEBUG
    for(j=0; j<n; j++){
        printf("%d  ", D[j].key);
    }
    printf("\nthe %d lap:fist=%d, final=%d\n\n", i, first, final);
#endif

    for(i=2; i<=L->length; i++){
        if(LT(L->r[i].key, D[first].key)){
            // 待插入元素比最小的元素小 
            first = (first-1+n)%n;
            D[first] = L->r[i];
        }else if(LT(D[0].key, L->r[i].key)){
            // 待插入元素比最大的元素大
            final = (final+1)%n;
            D[final] = L->r[i];
        }else{
            // 待插入元素处在最小元素和最大元素中间
            // 采用直接插入排序的方法，插入到数组D中合适的位置
            k = (final+1)%n;
            while(LT(L->r[i].key, D[(k-1+n)%n].key)){
                D[(k+n)%n] = D[(k-1+n)%n];
                k = (k-1+n)%n;
            }
            D[(k+n)%n] = L->r[i];
            final = (final+1)%n;
        }
#ifdef DEBUG
        for(j=0; j<n; j++){
            printf("%d  ", D[j].key);
        }
        printf("\nthe %d lap:fist=%d, final=%d\n\n", i, first, final);
#endif
    }
    //将排序记录复制到原来的顺序表里 
    for(j=0; j<n; j++){
        L->r[1+j] = D[first];
        first = (first+1)%n;
    }
}

int  main(int argc, char *argv[])
{
    if(argc < 2){
        return -1;
    }
    SqList L;
    int i = 0;
    for(i=1; i<argc; i++){
        if(i>MAXSIZE)
            break;
        L.r[i].key = atoi(argv[i]);
    }
    L.length = (i-1);

    TwoInsertSort(&L);
    PrintList(L);
    return 0;
}

 

运行

[jennifer@localhost Data.Structure]$ ./a.out 12 5 7 4 5 3 45 76
12 0 0 0 0 0 0 0 
the 0 lap:fist=0, final=0

12 0 0 0 0 0 0 5 
the 2 lap:fist=7, final=0

7 12 0 0 0 0 0 5 
the 3 lap:fist=7, final=1

7 12 0 0 0 0 4 5 
the 4 lap:fist=6, final=1

5 7 12 0 0 0 4 5 
the 5 lap:fist=6, final=2

5 7 12 0 0 3 4 5 
the 6 lap:fist=5, final=2

5 7 12 45 0 3 4 5 
the 7 lap:fist=5, final=3

5 7 12 45 76 3 4 5 
the 8 lap:fist=5, final=4

len:8; data:3 4 5 5 7 12 45 76 
[jennifer@localhost Data.Structure]$