二分查找插入排序

采用二分查找法，找到需要插入的index，以此改进传统的插入排序方法，代码如下：

#include <iostream>
#include <vector>
#include <time.h>
using namespace std;
const int num = 20000;

template <typename T>
void initArr(vector<T> &arr) {
    for(int i = 0; i < arr.size(); ++i) {
        arr[i] = rand() % 100 * 1.0 / 10 ;             // 产生0-10之间的数
    }
}

template <typename T>
void printArr(const vector<T> &arr) {
    for(int i = 0; i < arr.size(); ++i) {
        cout << arr[i] <<"  ";
    }
    cout << endl;
}

template <typename T>
void InserSort(vector<T> &arr) {
    for(int j = 1; j < arr.size(); ++j) {
        T key = arr[j];
        int i = j - 1;
        while(i >= 0 && key < arr[i]) {
            arr[i+1] = arr[i];
            --i;
        }
        arr[i+1] = key;
    }
}

template <typename T>
int BinarySearch(const vector<T> &arr, int start, int end, T k) {
    while(start <= end) {
        int mid = (start + end) / 2;
        int midData = arr[mid];
        if(midData > k) {
            end = mid - 1;
        } else {
            start = mid + 1;
        }
    }
    return start;
}

template <typename T>
void InserSort2(vector<T> &arr) {
    int i, j;
    for(i = 1; i < arr.size(); ++i) {
        if(arr[i] < arr[i-1]) {
            T tmp = arr[i];
            int insertIndex = BinarySearch(arr, 0, i, tmp);
            for(j = i - 1; j >= insertIndex; --j) {
                arr[j+1] = arr[j];
            }
            arr[insertIndex] = tmp;
        }
    }
}


int main() {
    srand(time(NULL));
    vector<double> array(num);
//    cout << "no initArr: ";
//    printArr(array);
    initArr(array);
//    cout << "after initArr: ";
//    printArr(array);
    time_t t1, t2, t3, t4;
    t1 = clock();
    InserSort(array);
    t2 = clock();
//    cout << "after InserSort: ";
//    printArr(array);
    cout << "InserSort cost time: " << double(t2 - t1)/CLOCKS_PER_SEC << endl;

    initArr(array);
    t3 = clock();
    InserSort2(array);
    t4 = clock();
//    cout << "after InserSort2: ";
//    printArr(array);
    cout << "InserSort2 cost time: " << double(t4 - t3)/CLOCKS_PER_SEC << endl;

    return 0;
}

运行结果如下：

结果表明，在数据量较大的情况下，二分查找插入排序的效率更高。

3.2. 复杂度分析
我们这个二分查找的算法并不会因为等于某一个值而停止查找，它将查找整个序列直到start<=end条件不满足而得到插入的位置，所以对于长度为n的数组来说，比较次数为log2n ,时间复杂度为O（log2n）。二分插入排序的主要操作为比较+后移赋值，则：

最坏情况：每次都在有序序列的起始位置插入，则整个有序序列的元素需要后移，时间复杂度为O（n^2）
最好情况：待排序数组本身就是正序的，每个元素所在位置即为它的插入位置，此时时间复杂度仅为比较时的时间复杂度，为O(log2n)
平均情况：O（n^2）
空间复杂度上， 二分插入排序也是就地排序算法，它的空间复杂度为O（1）.

3.3. 稳定性
二分插入排序是稳定的。元素的相对顺序在排序后不会被改变。