插入排序及其优化

  插入排序基本思想：将待排序列视为有序和无序两部分，首先将第1个记录视为有序，从第2个记录arr[1]开始，依次与前面的记录的关键字进行比较，若arr[1]小于arr[0]，则交换两者，此时待排序列的第1、2个记录组成有序部分，将第3个记录arr[2]依次与arr[1]、arr[0]进行比较，若arr[2]较小，则依次和前面的值进行交换，依次类推...

  插入排序的C++实现：

SortTestHelper.h头文件（其中包含用于排序算法的各种辅助函数）

#include <iostream>
#include <cstdlib>
#include <ctime>  //clock()、CLOCKS_PER_SEC
#include <cassert>  //包含函数assert()

using namespace std;

namespace SortTestHelper
{
    //辅助函数 - 随机产生一个数组
    int* generateRandomArray(int n, int RangeL, int RangeR)  //返回数组首地址
    {
        //判断RangeL是否<=RangeR
        assert(RangeL <= RangeR);  //参数为表达式，表达式为真时返回true，否则打印错误信息

        int *arr = new int[n];
        srand(time(0));
        for(int i = 0; i < n ; i++)
        {
            arr[i] = rand() % (RangeR - RangeL + 1) + RangeL;  //使得产生的随机数在RangeL和RangeR之间
        }
        return arr;
    }

    //辅助函数 - 产生一个近乎有序的随机数组
    int* generateNearlyOrderedArray(int n, int swapTime)
    {
        int *arr = new int[n];
        for(int i = 0; i < n; i++)
        {
            arr[i] = i;  //先生成一个完全有序的数组
        }
        //然后交换几组元素，使之变成无序但近乎有序的数组
        srand(time(0));
        for(int j = 0; j < swapTime; j++)
        {
            //随机生成一个x位置和y位置
            int posx = rand() % n;
            int posy = rand() % n;
            //交换x和y处的元素
            swap(arr[posx], arr[posy]);
        }
        return arr;
    }

    //辅助函数 - 打印数组
    template<typename T>
    void printArray(T arr[], int n)
    {
        for(int i = 0; i < n; i++)
        {
            cout << arr[i] << " ";
        }
        cout << endl;
    }

    //辅助函数 - 判断数组是否有序（升序）
    template<typename T>
    bool isSorted(T arr[], int n)
    {
        for(int i = 0; i < n - 1; i++)
        {
            if(arr[i] > arr[i + 1])
            {
                return false;
            }
        }
        return true;
    }

    //辅助函数 - 测试算法的时间
    template<typename T>
    void testSort(string sortname, void(*sort)(T[], int), T arr[], int n)  //arr[]和n是函数指针需要的参数
    {
        clock_t starttime = clock();
        sort(arr, n);  //调用函数sort()
        clock_t endtime = clock();

        //判断排序是否成功
        assert(isSorted(arr, n));  //若是数组无序，则assert会自动调用abort()退出程序，不会执行下面的语句

        cout << sortname << " needs " << double(endtime - starttime) / CLOCKS_PER_SEC << "s." << endl;
    }

    //辅助函数 - 拷贝数组
    int* copyIntArray(int a[], int n)
    {
        int *arr = new int[n];
        //使用C++函数copy()
        copy(a, a + n, arr);
        return arr;
    }
}

#include <iostream>
#include <algorithm>
#include "SortTestHelper.h"
template<typename T>
void insertionSort(T arr[], int n)
{
    for(int i = 1; i < n; i++)
    {
        for(int j = i; j > 0 && arr[j] < arr[j - 1]; j--)
        {
            swap(arr[j], arr[j - 1]);  //每次交换需要3次赋值操作
        }
    }
}
int main()
    {
        int n = 10000;
        int *arr = SortTestHelper::generateRandomArray(n, 0, n);
        SortTestHelper::testSort("insertionSort", insertionSort, arr, n);
        delete[] arr;
        return 0;
    }

  插入算法中有提前终止循环的条件for(int j = i; j > 0 && arr[j] < arr[j - 1]; j--)，这本应该使得插入排序比选择排序时间性能更好，但是可以比较该插入算法和简单选择排序，可以测试得到该插入算法反而耗时更长。

  从算法代码可以看出，比较耗时的操作在于每向前找到一个大于当前值的位置，都需要进行一次交换，而每一次swap都需要经过3次交换赋值，因此和简单选择排序相比，这种算法反而耗时更长，接下来对该插入算法进行优化。

  优化的插入算法：即先将待插入数据拷贝一份副本，存放在T e中，然后寻找合适的插入位置时仅进行移动而不进行交换，记录下最终找到的合适位置下标j，最后将e插入到arr[j]即可。即用赋值取代交换可以减少耗费的时间。

  优化的插入算法如下：

template<typename T>
void insertionSort(T arr[], int n)
{
    for(int i = 1; i < n; i++)
    {
        T e = arr[i];
        //在arr[0...i]寻找插入位置j
        int j;
        for(j = i; j > 0 && arr[j - 1] > e; j--)
        {
            arr[j] = arr[j - 1];
        }
        //将e插入到arr[j]
        arr[j] = e;
    }
}