直接插入排序

直接插入排序（straight insertion sort），有时也简称为插入排序（insertion sort），是减治法的一种典型应用。其基本思想如下：

• 对于一个数组A[0,n]的排序问题，假设认为数组在A[0,n-1]排序的问题已经解决了。
• 考虑A[n]的值，从右向左扫描有序数组A[0,n-1]，直到第一个小于等于A[n]的元素，将A[n]插在这个元素的后面。

　　很显然，基于增量法的思想在解决这个问题上拥有更高的效率。

直接插入排序对于最坏情况（严格递减的数组），需要比较和移位的次数为n(n-1)/2；对于最好的情况（严格递增的数组），需要比较的次数是n-1，需要移位的次数是0。当然，对于最好和最坏的研究其实没有太大的意义，因为实际情况下，一般不会出现如此极端的情况。然而，直接插入排序对于基本有序的数组，会体现出良好的性能，这一特性，也给了它进一步优化的可能性。（希尔排序）。直接插入排序的时间复杂度是O(n^2)，空间复杂度是O(1)，同时也是稳定排序。

下面用一个具体的场景，直观地体会一下直接插入排序的过程：

场景：

现有一个无序数组，共7个数：89 45 54 29 90 34 68。

使用直接插入排序法，对这个数组进行升序排序。

89 45 54 29 90 34 68

45 89 54 29 90 34 68

45 54 89 29 90 34 68

29 45 54 89 90 34 68

29 45 54 89 90 34 68

29 34 45 54 89 90 68

29 34 45 54 68 89 90

#include<iostream>
#include<algorithm>

using namespace std;

void OutNum(int *nNum, size_t len)
{
	// 异常处理
	if (nNum == NULL)
		return;

	for (size_t i = 0; i < len; i++)
		cout << nNum[i] << ' ';
	cout << endl;
}

void InsertSort(int* nNum, int nLen)
{
	// 异常处理
	if (NULL == nNum)
		return;

	for (int i = 1; i < nLen; i++) {
		int nKey = nNum[i];

		//代表已经排过序的元素最后一个索引数
		int j = i - 1;
		while (j >= 0 && nKey < nNum[j]) {
			//从后向前逐个比较已经排序过数组，如果比它小，则把后者用前者代替，
			//其实说白了就是数组逐个后移动一位,为找到合适的位置时候便于Key的插入
			nNum[j + 1] = nNum[j];
			j--;
		}
		//找到合适的位置了，赋值,在i索引的后面设置key值。
		nNum[j + 1] = nKey;
	}
}

void InsertSort2(int* nNum, int nLen)
{
	// 异常处理
	if (NULL == nNum)
		return;

	for (int i = 1; i < nLen; i++) {
		for (int j = i - 1; j >= 0; j--) {
			if (nNum[j] > nNum[j + 1]) {
				swap(nNum[j], nNum[j + 1]);
			}
			else {
				break;
			}
		}
	}
}
int main()
{
	//int nNum[10] = {1,7,4,5,3,8,6,9,0,2};
	//int nNum[10] = { 0,1,2,3,4,5,6,7,8,9 };
	//int nNum[10] = { 0,1,2,3,4,5,6,7,9,8 };
	//	int nNum[20] = { 20,40,50,10,60, 1,7,4,5,3 };
	int nNum[20] = { 5,0,-8,2,3,4,7,-7,8,1,10,-2,-3,-4,6,-5,-6,9,-9,-1 };

	InsertSort(nNum, 20);

	OutNum(nNum, 20);
	return 0;
}