【数据结构】 插入排序 （包括复杂度，稳定性） （直接插入排序，折半插入排序，希尔排序的代码实现）

定义好数组长度和待排数组，其中A[0]用作暂存空间，或者哨兵

const int N = 9;
int A[N] = { 0,49,38,65,97,76,13,27,49 };

插入排序
稳定性：        稳定       
最好时间复杂度： O(n)  
最坏时间复杂度:  O(n^2)
空间复杂度：     O(1)

void InsertSort() { 
	int i, j;
	for (int i = 2; i < N; i++) { //从第二个元素开始
		if (A[i] < A[i - 1]) {
			A[0] = A[i]; int j;
			for (j = i - 1;A[j] > A[0]; j--)//碰到A[0]必然不满足条件
				A[j + 1] = A[j];
			A[j+1] = A[0];
		}
		travel(); cout << endl;
	}
}

折半插入排序  （折半查找的过程虽然减少了比较的次数，但是其移动的次数还是没有变，
                所以还是O(n^2)的时间复杂度）
稳定性：        稳定
最好时间复杂度： O(n)
最坏时间复杂度:  O(n^2)
空间复杂度：     O(1)

void Binary_InsertSort() {
	int i, j, low, high;
	for (int i = 2; i < N; i++) {
		low = 1; high = i - 1; A[0] = A[i];
		while (low <= high) {
			int mid = (low + high) / 2;
			if (A[0] >= A[mid])
				low = mid + 1;
			else
				high = mid - 1;
		}
/*
	经过上面的查找过程，low>high;
	此时low及其右边的元素都大于A[0],high及其左边的元素都小于或者等于A[0]；
	所以我们需要将low及其右边的元素全部右移。
*/
		for (int j = i - 1; j >= low; j--) {
			A[j+1] = A[j];
		}
		A[low] = A[0];
		travel();
	}
}

希尔排序
稳定性：        不稳定
最好时间复杂度： 在某些情况下O(n^1.3)
最坏时间复杂度:  O(n^2)
空间复杂度：     O(1)

这个版本是实现了王道书上的希尔排序，但是不是我们所直接理解
的那样利用增量序列将原数组分成多个序列分别进行插入排序。
而是进行交替插入排序，这是因为i++;

所选增量序列选择为N/2 N/4 N/8 N/16 ……

void ShellSort1() {
	//第一个循环进行增量序列的选择
	for (int d = N / 2; d >= 1; d = d / 2) {
		//第二个循环对于不同的序列进行交替插入排序，
		for (int i = d+1; i < N; i++)//注意i++而不是i = i+d；说明了这是交替在不同的序列中进行插入排序。
			if (A[i] < A[i - d]) {
				A[0] = A[i]; int j;
				for (j = i - d; j > 0 && A[j] > A[0]; j-=d) 
					A[j + d] = A[j];
				A[j + d] = A[0];
			}
	}
}

下面这个版本是我们所理解的那样，比较符合我们的逻辑，
第一步分为多个序列，
第二部对每个序列进行完整的插入排序

int d[3] = {4,2,1};//增量序列数组
void ShellSort2() {
	int cnt = 0;
	while (cnt<3) {//选取增量
		//对划分的每一个序列都进行增量排序。
		for (int k = 1; k <= d[cnt]; k++) 
			//下面的部分就是插入排序了。
			for (int i = d[cnt] + k; i < N; i += d[cnt]) {
				A[0] = A[i]; int j;
				if (A[0] < A[i - d[cnt]]) {
					for (j = i - d[cnt]; j > 0 && A[0] < A[j]; j -= d[cnt])
						A[j + d[cnt]] = A[j];
					A[j + d[cnt]] = A[0];
				}
			}//for
		cnt++;
	}//while
}