C++插入排序

C++插入排序

插入排序思想：将数组分成两组，第一个数组值为一组并认为该数组为有序的，并从后面数组n-1个数中逐个选择与已经有序的数组进行比较，插入到已经排序好的数组中，直至数组中的所有数组有序排列为止。这样的话，n个元素需要进行n-1趟排序！！！

数组A[]={2,1,4,5,3,8,7,9,0,6},length=10;

i=1，j=0，a[j+1]=1<a[j] =2，故交换a[j]，a[j+1]，数组 a[]={1,2,4,5,3,8,7,9,0,6}。

i=1，j=-1，不做任何操作。

i=2，j=1，a[j+1]=4>a[j] =2，不做任何操作，数组不改变。

i=3，j=2，a[j+1]=5>a[j] =4，不做任何操作，数组不改变。

i=4，j=3，a[j+1]=3<a[j] =5，故交换a[j]，a[j+1]，数组 a[]={1,2,4,3,5,8,7,9,0,6}。

i=4，j=2，a[j+1]=3<a[j] =4，故交换a[j]，a[j+1]，数组 a[]={1,2,3,4,5,8,7,9,0,6}。

i=4，j=1，a[j+1]=3>a[j] =2，不做任何操作，数组不改变。

i=5，j=4，a[j+1]=8>a[j] =5，不做任何操作，数组不改变。

i=6，j=5，a[j+1]=7<a[j] =7，故交换a[j]，a[j+1]，数组 a[]={1,2,3,4,5,7,8,9,0,6}。

i=6，j=4，a[j+1]=7>a[j] =5，不做任何操作，数组不改变。

i=7，j=6，a[j+1]=9>a[j] =8，不做任何操作，数组不改变。

i=8，j=7，a[j+1]=0<a[j] =9，故交换a[j]，a[j+1]，数组 a[]={1,2,3,4,5,7,8,0,9,6}。

j--，直到数组 a[]={0,1,2,3,4,5,7,8,9,6}。

i=9，j=8，a[j+1]=6<a[j] =9，故交换a[j]，a[j+1]，数组 a[]={0,1,2,3,4,5,7,8,6,9}。

j--，直到数组 a[]={0,1,2,3,4,5,6,7,8,9}。

（一）普通插入排序

每次取一个，按次在前面已排好序的区间中 依次比较找到第一个大于当前待排数据的位置，然后移动原有数据，插入新的数据。

• 时间复杂度（主要是看移动次数）
  ——最好情况：O（n）
  ——最坏情况和平均：O（n^2）
• 空间复杂度
  ——O（1）：原地排序
• 稳定性
  ——可做到稳定
• 相比冒泡排序的优点
  ——移动只需一次赋值操作

void InsertSort(int a[],int N){
	cout<<"befort: ";
	for(int i=0;i<N;i++)
		cout<<a[i]<<" ";
		cout<<endl;
	for(int i=1;i<N;i++)
	{
		if(a[i]<a[i-1])
		{
			int temp=a[i];
			int j=0;
			for(j=i-1;j>=0 && (temp<a[j]);j--)  
				a[j+1]=a[j];
				a[j+1]=temp;
			}
		}
		cout<<"after: ";
		for(int i=0;i<N;i++)
			cout<<a[i]<<" ";
			cout<<endl;
}

时间复杂度分析： 若将待排序的数据元素按从小到大的顺序排序，可分为最好情况和最坏情况讨论。

(1).最好的情况：最好的情况就是待排序的数据已经排好序了，这时只需要进行（n-1)次比较操作。
(2).最坏的情况：最坏的情况就是待排序的数据序列是逆序的。此时需要进行的比较次数为n(n-1)/2次，赋值操作是比较操作的次数n(n-1)/2+(n-1）次。平均来说插入排序算法的时间复杂度为O(n^2）。

注：插入排序不适合对于数据量比较大的排序应用

（二）二分插入排序

因为在排序的时候，需要在有序数组中寻找可以插入的位置，所有通过二分寻找插入位置。与普通的相同，只不过在找插入位置时，由于前面的都是已排好序的，所以可以用二分查找来加速。(此处二分查找查找第一个大于待插入数据的位置)

/*
折半插入排序
a：待排序元素集合
n：集合中元素的个数
步骤：
（1）选取无序区中第一个元素i
（2）在有序区间折半搜索该元素应该插入的位置
（3）将该元素插入合适位置
（4）重复（1）（2）（3）直至无序区长度为0
*/
template<typename T>
void BinaryInsertSort(T a[], int n)
{
	for (int i = 1; i < n; i++) //每次选取无序区间的第一个元素插入
	{
		T t = a[i];
		int left = 0, right = i - 1; //折半寻找插入位置
		while (left <= right)
		{
			int mid = (left + right) / 2; //取区间中间位置
			if (t < a[mid]) right = mid - 1; //插入点在左半区
			else left = mid + 1; //插入点在右半区（为保证排序稳定性，如果有元素相等，则在该元素后插入）
		}
		int j = i - 1;
		while (j >= right + 1) //移动元素 
		{
			a[j + 1] = a[j];
			j--;
		}
		a[j + 1] = t; //插入元素到有序区
	}
}

• 时间复杂度（主要是看移动次数）
  ——最好情况：O（n）
  ——最坏情况和平均：O（n^2）
• 空间复杂度
  ——O（1）：原地排序
• 稳定性
  ——可做到稳定

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