插入排序

中心思想：考虑你正在斗地主，对方发给你一堆牌，你右手摸牌,左手拿牌，第一次摸到10放到左手，第二次摸到3就放到10左边，第三次摸到K放10右边，左手上的牌一直保持有序，直到左手拿着所有的牌为止。这就是插入排序。
插入排序从第二个元素开始，在前面已排好序的序列中寻找合适的位置并插入，使之仍然有序。
插入排序最多的步骤在于移位操作，每个元素插入之前，数组的大于待插入值的元素必须事先挪位，故插入排序在最坏情况下是o（n*n）的复杂度。

直接插入：

//插入排序，不支持参数检查
void insert_sort(int * a , int n)
{
    int i,j,key;
    for(i=1;i<n;++i)
    {
        key = a[i];//key 为待插入的元素
        //挪位
        for( j = i-1;j>=0 && a[j] >key;--j)
        {
            a[j+1] = a[j];//两重循环，故O（n*n）
        }
        //在合适的位置插入
        a[j+1] = key;
    }
}

在一万个数据的运行结果：

插入排序有个挪位操作，每次循环必须判断移动的元素是否大于待插入的元素，为了省去不必要的判断，我们可以先用二分法寻找合适的插入位置。

折半插入：

void insert_sort(int * a , int n)
{
    int i,j,key,low,high,mid;
    for(i=1;i<n;++i)
    {
        key = a[i];
        //二分查找运算
        low = 0,high = i-1;
        while(low <= high)
        {
            mid = (low + high)/2;
            if(key > a[mid])
                low = mid + 1;
            else// if(key <= a[mid])
                high = mid - 1;

        }
        //挪位
        for( j = i-1;j >= low;--j)
        {
            a[j+1] = a[j];
        }
        a[j+1] = key;
    }
}

在一万个数据的运行结果：

结果快了大概十多毫秒。。。我想应该是移位操作步数并没有因此减少，只是对比较操作优化了一下而已。所以效果并不明显。

二路插入：

那么有没有办法减少移位的步数呢？仔细一想，有一种情况是不需要移位的，那就是待插入的元素刚好插入到有序序列的最后。我们想一下，如果有序序列前面还有位置放会怎样？本来需要把所有有序序列移位的现在也变成不需要移位了。那么如何实现呢？我们可以利用循环数组的想法来做。用first表示有序序列的开始，last表示有序序列的结尾，如果待插入元素小于first值或者大于last值，就放到外面去；如果待插入元素刚好处于first值和last值之间，那么就插入到有序序列中间，这和直接插入一样。
举例：如果有序序列是 1 2 3 5，待插入的是0，那么我就把它放到数组的最后，让first等于最后一个（first = n -1），让last = 2。
二路插入的思想是以空间换取时间的想法。

---

void insert_sort(int * a , int n)
{
    int *t;
    t = new int [n];
    int i,j,key,first=0,last=0;
    t[0] = a[0];

    for(i=1;i<n;++i)
    {
        key = a[i];//key 为待插入的元素
        //如果待插入元素比first值还小
        if(key <= t[first])
        {
            first = (first-1+n)%n;
            t[first] = key;

        }
        //如果待插入元素比last值还大
        else if(key >= t[last])
        {
            last = last + 1;
            t[last] = key;

        }
        //如果待插入元素处于first和last之间
        else //if(key > t[first] && key < t[last])
        {
            //挪位
            for( j = last;j != first && t[j] > key; j= (j-1+n)%n)
            {
                t[(j+1)%n] = t[j];//两重循环，故O（n*n）
            }
            //在合适的位置插入
            t[(j+1)%n] = key;
            last = (last + 1)%n;
        }


    }
    //赋值给a数组
    j=0;
    i =first;
    do{
         a[j++] = t[i];
         i = (i+1)%n;
    }while(i != (last + 1)%n);
}

---

但是运行结果却出乎意料：

但是对于完全逆序的数据却出乎意料的快：

经过仔细分析，原来是取余（循环链表需要用到模运算）造成的影响，于是修改一下：

void insert_sort(int * a , int n)
{
    int *t;
    t = new int [n];
    int i,j,key,first=0,last=0;
    t[0] = a[0];

    for(i=1;i<n;++i)
    {
        key = a[i];//key 为待插入的元素
        //如果待插入元素比first值还小
        if(key <= t[first])
        {
            first = (first-1+n)%n;
            t[first] = key;

        }
        //如果待插入元素比last值还大
        else if(key >= t[last])
        {

            t[++last] = key;

        }
        //如果待插入元素处于first和last之间
        else //if(key > t[first] && key < t[last])
        {
            //挪位
            int k1,k2;
            for( j = last;j != first && t[j] > key; j= (!j)?(j-1+n):j-1)//避免取余带来的性能损耗
            {
                k1= (!(j-n+1))?j+1-n:j+1;
                t[k1] = t[j];//两重循环，故O（n*n）
            }
            //在合适的位置插入
            t[(!(j-n+1))?j+1-n:j+1] = key;
            ++last;
        }


    }
    //赋值给a数组
    j=0;
    i =first;
    do{
         a[j++] = t[i];
         i = (!(i-n+1))?i+1-n:i+1;
    }while(i != last + 1);
}

运行结果：

我只能说我已经尽力了，对于均匀随机产生的数据，二路插入只有70多毫秒，比直接插入还要慢一点，但是对于极端情况即完全逆序或者完全升序的情况来说是很快的，权衡一下应该选择二路插入好一点。

希尔排序：

为了省略移位带来的影响，希尔提出了这样一种思路：如果待排序的数组元素相对有序，那么是否会降低移位操作的频率？
如果在插入元素之前，数组都相对有序，大的元素都在后头，小的元素都在前面，这样只需移动少许的元素就可以使数组升序。
上代码：

void insert_sort(int * a , int n)
{
    int i,j,key,step;//step 为步长
    step = n >>1;
    while(step!=0)
    {
        //cout<<step<<endl;
        for(i=0;i<n;i += step)
        {
        key = a[i];//key 为待插入的元素
        //挪位
        for( j = i-step;j>=0 && a[j] >key;j -= step)
        {
            a[j+step] = a[j];//两重循环，故O（n*n）
        }
        //在合适的位置插入
        a[j+step] = key;
        }
        step = step >>1;
    }
}

我感觉希尔排序跟直接插入排序的代码差不多，不同的是下标值的变换，希尔排序会依次缩小步长，增大待排序的元素，直到步长为1，即变成了直接插入排序，但由于之前的排序是数组相对有序（大小错落有致），所以移位运算大大减少，因此性能得到提高：

以上，便是插入排序的大致内容，这是我的第一篇博客，谢谢观看。