排序算法3——图解直接插入排序以及折半（二分）插入排序及其实现

排序算法1——图解冒泡排序及其实现（三种方法，基于模板及函数指针）
排序算法2——图解简单选择排序及其实现
排序算法3——图解直接插入排序以及折半（二分）插入排序及其实现
排序算法4——图解希尔排序及其实现
排序算法5——图解堆排序及其实现
排序算法6——图解归并排序及其递归与非递归实现
排序算法7——图解快速排序以及不同CUTOFF的时间测试

---

一、直接插入的基本思想

将待排序的一组序列分为已排好序和未排好序的两个部分
初始状态时，已排好序序列仅包含第一个元素，未排好序的序列元素为除去第一个以外的n-1个元素
然后，将未排好序序列中的元素逐一插入到已排好序的序列中
如此往复，经过n-1次插入后，未排序序列中的元素个数变为0，排序完成。如下图所示

代码及上下界如图

从代码可以看出，空间复杂度上，简单插入排序仅需要常数个额外空间
在时间复杂度上，函数中有两个嵌套的循环，每个循环进行O（N）次比较和交换，故时间复杂度为O（N^2）
此外，简单插入排序是稳定的排序，
可以在下面的具体过程中看到，数值相同的两个记录不会发生相对位置上的改变

具体过程




后面就不列出了

---

二、折半（二分）插入排序

虽然它的时间复杂度也是O（N^2），但由于引用了二分的思想，它的平均性能会比直接插入好

总的来说，插入法比冒泡法和简单选择排序法的性能好一些

三、测试结果及代码

#include <iostream>

template<class T>
void InsertSort(T *a, int length) {
	T tmp;
	int i, j;
	for (i = 1; i < length; ++i) {
		tmp = a[i];
		for (j = i; j > 0 && a[j - 1] > tmp; --j) {
			a[j] = a[j - 1];
		}
		a[j] = tmp;
	}
}

template<class T>
void BinaryInsertSort(T *a, int length) {

	int left, right, mid;
	int tmp;
	for (int i = 1; i < length; i++) {
		/* 找到数组中第一个无序的数，保存为tmp */
		if (a[i] < a[i - 1]) {
			tmp = a[i];
		}
		else {
			continue;
		}
		/* 找到数组中第一个无序的数，保存为tmp */

		/* 二分查询开始 */
		left = 0;
		right = i - 1;
		while (left <= right) {
			mid = (left + right) / 2;
			if (a[mid] > tmp) {
				right = mid - 1;
			}
			else {
				left = mid + 1;
			}
		}
		/* 二分查询结束,此时a[left]>=a[i],记录下left的值 */

		/* 将有序数组中比要插入的数大的数右移 */
		for (int j = i; j > left; j--) {
			a[j] = a[j - 1];
		}
		/* 将有序数组中比要插入的数大的数右移 */

		// 将left位置赋值为要插入的数
		a[left] = tmp;
	}
}


template<class T>
void ArrShow(T *a, int length) {
	for (int i = 0; i < length; ++i) {
		std::cout << a[i] << " ";
	}
	puts("\n");
}

int main(int argc, char *argv[]) {
	int test[9] = { 9, 1, 5, 8, 3, 7, 4, 6, 2 };
	ArrShow(test, 9);

	puts("InsertSort : ");
	InsertSort(test, 9);
	ArrShow(test, 9);

	int test1[9] = { 9, 1, 5, 8, 3, 7, 4, 6, 2 };
	puts("BinaryInsertSort : ");
	BinaryInsertSort(test1, 9);
	ArrShow(test1, 9);

	return 0;
}