数据结构与算法简记：折半插入排序

上次记录了直接插入排序的算法，这种排序算法需要在每一轮插入操作前，拿待插入元素跟前面排好序的元素逐个进行比较，然后找到合适的位置，这种逐个比较的做法其实是不必要的，因为前面的序列已经是排好序的，我们可以通过折半查找方式快速找到该位置，进而可以节省不少运算成本。

折半查找通过高位和低位来限制数据区间，然后获取中间位和它的元素值，跟待插入元素值比较，如果大于待插入元素，则区间折半为前半部分，相似地，如果小于待插入元素，则区间折半为后半部分，继续获取中间位及其值，跟待插入元素比较。

最终我们可以获取到一个合适的位置，先将这个位置及以后的元素统一向后挪动一位，然后将带插入元素值放入这个位置。

下面是实现代码：

JS版：

//获取插入位置
function getInsertPosition(array, keyIndex) {
  var key = array[keyIndex];

  var low = 0, high = keyIndex - 1;
  var mid;

  while (low <= high) {
    mid = Math.floor((low + high) / 2);

    if (array[mid] > key) {
      //如果中间位置的值大于当前key值，则高位变为mid-1，在前半部分继续比较
      high = mid - 1;
    } else {
      //如果中间位置的值小于当前key值，则低位变为mid+1，在后边部分继续比较
      low = mid + 1;
    }
  }

  //high+1即要插入的位置
  return high + 1;
}

//折半插入排序
function binaryInsertSort(array) {
  var i, j, key;
  var size = array.length;

  var position;

  for (i = 1; i < size; i++) {  //从第二个元素开始向前插入
    j = i;
    key = array[j];             //保存当前位置的值

    //找到合适的插入位置
    position = getInsertPosition(array, j);

    while (j > position) {
      array[j] = array[j - 1];  //逐个向后挪动
      j--;
    }

    array[position] = key;      //插入到正确的位置
  }
}

var array = [39, 28, 57, 12, 95, 45, 10, 73];

binaryInsertSort(array);

console.log(array);

Java版：

package algorithm;

public class Sorting {

    private static int getInsertPosition(int[] array, int keyIndex) {
        int key = array[keyIndex];

        int low = 0, high = keyIndex - 1;
        int mid;

        while (low <= high) {
            mid = (low + high) / 2;

            if (array[mid] > key) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }

        return high + 1;
    }

    public static void binaryInsertSort(int[] array) {
        int i, j, key;
        int size = array.length;

        int position;

        for (i = 1; i < size; i++) {
            j = i;
            key = array[j];

            position = getInsertPosition(array, j);

            while (j > position) {
                array[j] = array[j - 1];
                j--;
            }

            array[position] = key;
        }
    }

    public static void main(String[] args) {
        int[] array = {39, 28, 57, 12, 95, 45, 10, 73};

        Sorting.binaryInsertSort(array);

        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
}

C语言版：

#include <stdio.h>

void binaryInsertSort(int *array, int size);
int getInsertPosition(int *array, int keyIndex);

int main(int argc, const char * argv[]) {

    int array[] = {39, 28, 57, 12, 95, 45, 10, 73};

    int size = sizeof(array) / sizeof(array[0]);

    binaryInsertSort(array, size);

    for (int i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }

    return 0;
}

void binaryInsertSort(int *array, int size) {

    int i, j, key;

    int position;

    for (i = 1; i < size; i++) {
        j = i;
        key = array[j];

        position = getInsertPosition(array, j);

        while (j > position) {
            array[j] = array[j - 1];
            j--;
        }

        array[position] = key;
    }
}

int getInsertPosition(int *array, int keyIndex) {
    int key = array[keyIndex];

    int low = 0, high = keyIndex - 1;
    int mid;

    while (low <= high) {
        mid = (low + high) / 2;

        if (array[mid] > key) {
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }

    return high + 1;
}