插入排序及其优化

插入排序：把一个无序的数组分为两部分，一部分为有序（刚开始只有一个元素），一部分为无序（从第二个元素开始），将无序元素一个一个插入到有序元素中。

void InsertSort(int *arr, size_t size)
{
    for(int i=1; i<size; ++i)
    {
        if(arr[i]<arr[i-1])
        { 
            int j = i-1;
            int x = arr[i];
            arr[i] = arr[i-1];
            while(x<arr[j-1])
            {
                arr[j]=arr[j-1];
                j--;
            }
            arr[j] = x;
        }
    }
}

直接插入排序耗时的操作有：比较+后移赋值。时间复杂度如下：
1) 最好情况：序列是升序排列，在这种情况下，需要进行的比较操作需（n-1）次。后移赋值操作为0次。即O(n)
2) 最坏情况：序列是降序排列，那么此时需要进行的比较共有n(n-1)/2次。后移赋值操作是比较操作的次数加上 (n-1）次。即O(n^2)
3) 渐进时间复杂度（平均时间复杂度）：O(n^2)
2. 空间复杂度：O(1)
从实现原理可知，直接插入排序是在原输入数组上进行后移赋值操作的（称“就地排序”），所需开辟的辅助空间跟输入数组规模无关，所以空间复杂度为：O(1)

优化改进
1.二分查找插入排序：利用二分查找迅速找到插入位置，减少元素比较次数提高效率。

void InsertSort(int *arr, size_t size)
{
    int i=0;
    for(i=1; i<size; ++i)
    {
        int index = BinarySearchInsert(arr, i, arr[i]);//返回插入位置。
        if(i != index)
        {
            int j = i;
            int temp = arr[j];
            while(j!=index)
            {
                 arr[j] = arr[j-1];
                 j--;
            }
            arr[j]=temp;
        }
    }
}


int BinarySearchInsert(int arr[], size_t size, int data)
{
    int begin = 0;
    int end = size-1;
    int middle=-1;
    while(begin<=end)
    {
        middle = (end-begin)/2+begin;
        if(data>arr[middle])
        {
            begin = middle+1;
        }else
        {
            end = middle-1;
        }
    }
    if(arr[middle]<=data)
        middle++;
    return middle;
}

这里找的是插入位置，不是查找元素，所以必须比较完所有元素，二分查找最坏时间复杂度为log2(N)
所以二分查找插入排序时间复杂度：
最好情况：查找的位置是有序区的最后一位后面一位，则无须进行后移赋值操作，其比较次数为：log2（N） 。即O(log2（N）)
最坏情况：查找的位置是有序区的第一个位置，则需要的比较次数为：log2（N），需要的赋值操作次数为n(n-1)/2加上 (n-1) 次。即O(n^2)
渐进时间复杂度（平均时间复杂度）：O(n^2)
空间复杂度：O(1)
希尔排序：如果序列本来就是升序或部分元素升序，那么比较+后移赋值操作次数就会减少。希尔排序正是通过分组的办法让部分元素升序再进行整个序列排序。（原因是，当增量值很大时数据项每一趟排序需要的个数很少，但数据项的距离很长。当增量值减小时每一趟需要和动的数据增多，此时已经接近于它们排序后的最终位置。）

void ShellSort(int *arr,size_t size)
{
int gap=size/3+1; //这个公式可以提高效率
while(gap>0)
{
for(int i=0; i<gap; ++i)
{
for(int j=gap+i;j<size;j+=gap)
{
if(arr[j]<arr[j-gap]) //小于之后向前移
{
int temp = arr[j];
int k = j-gap;
while(k>=0 && arr[k]>temp)
{
arr[k+gap] = arr[k];
k=k-gap;
}
arr[k+gap] = temp;
}
}
}
--gap;
}
}

时间复杂度: O(nlog2n)
希尔排序耗时的操作有：比较 + 后移赋值。时间复杂度如下：
最好情况：序列是升序排列，在这种情况下，需要进行的比较操作需（n-1）次。后移赋值操作为0次。即O(n)
最坏情况：O(nlog2n)。
渐进时间复杂度（平均时间复杂度）：O(nlog2n)