排序算法（二）、插入排序 —— 直接插入排序 和 希尔排序

    很多教科书上都是这么描述的： 插入排序的基本思想在于每次将一个待排序的记录，按照其关键字的大小，插入到前面已经排好序的子序列中，直到全部记录插入完成。

1、直接插入排序

    用通俗的语言表述一下直接插入排序过程：比如数组 a[5] = {1,2,3,6,4};

(1)设置两个循环。外层循环遍历所有的元素。内层元素遍历外层循环遍历到的那个元素（比如说 a[2]，也就是 3）的前面所有的元素（也就是 a[1],a[0]）

(2)若按照升序排序（降序排序同理）。依次将内层循环遍历的那些数字（比如a[1],a[0]）, 和外层循环当前遍历到的那个数字（此处为a[2]）进行比较，如果在 a[2]  前面的数字，有比 a[2] 大的，就将数据进行后移。

(3) 注意一点：对于外层循环依次遍历到的那个数字，它之前的数据都已经是有序的了。

所谓的“插入”，其实就是将外层循环遍历到的那个数据 a[i]，往前插入到在它前面的已经排好序的序列a[0],a[1]....a[i-1] 中恰当的位置。

C 程序如下：

#include<iostream>
#include<stdio.h>

using namespace std;

void sort1(int a[], int n)
{
	int i, j;
	for (i = 1; i < n; i++) // 遍历外层循环
	{
		if (a[i] < a[i - 1]) 如果遍历到的值比前一个值小，那么，进行内层循环的遍历，即当前数值得前面所有值
		{
			int temp = a[i];
			for (j = i - 1; j >= 0 && a[j] > temp; j--)
			{
				a[j + 1] = a[j];
			}
			a[j + 1] = temp;
		}
		
	}
}

int main()
{
	int a[5] = { 1, 3, 5, 7, 2 };
	sort1(a,5);
	for (int i = 0; i < 5; i++)
		cout << a[i] << endl;  // 输出的是 1 2 3 5 7
	return 0;
}

更简洁一点的版本为：

#include<iostream>
#include<algorithm>

using namespace std;

void sort1(int a[], int n)
{
	int i, j;
	for (i = 1; i < n; i++)
	{
		for (j = i - 1; j >= 0 && a[j] > a[j + 1]; j--)
			swap(a[j],a[j+1]);
	
	}
}

int main()
{
	int a[5] = { 1, 3, 5, 7, 2 };
	sort1(a,5);
	for (int i = 0; i < 5; i++)
		cout << a[i] << endl;
	return 0;
}

但是别忘记了包含 algorithm 头文件

Python 程序如下：

def insert_sort(L):
  #遍历数组中的所有元素，其中0号索引元素默认已排序，因此从1开始
  for x in range(1,len(L)):
  #将该元素与已排序好的前序数组依次比较，如果该元素小，则交换
  #range(x-1,-1,-1):从x-1倒序循环到0
      for i in range(x-1,-1,-1):
  #判断：如果符合条件则交换
          if L[i] > L[i+1]:
              temp = L[i+1]
              L[i+1] = L[i]
              L[i] = temp

补充两个动图，很形象。

2、希尔排序

希尔排序和快速排序很像。希尔排序的思想是将待排序的数组，按照步长 gap 进行分组，然后将每组的元素利用直接插入排序的方法进行排序；每次将 gap 折半进行减小，循环进行上述操作。当 gap = 1 时，完成排序。

由此可知，希尔排序有三个循环，最外层循环是将 gap 折半，对序列进行分组，直到 gap = 1。第二层和第三层循环，同直接插入排序。

C 程序如下：

#include<iostream>
#include<algorithm>

using namespace std;

void shellsort1(int a[], int n)
{
	int i, j, gap;
	for (gap = n / 2; gap > 0; gap /= 2)
	{
		for (i = gap; i < n; i++)
		{
			for (j = i - gap; j >= 0 && a[j] > a[j + gap]; j -= gap)
			{
				swap(a[j], a[j + gap]);
			}
		}
	}
}


int main()
{
	int a[5] = { 1, 3, 5, 7, 2 };
	shellsort1(a,5);
	for (int i = 0; i < 5; i++)
		cout << a[i] << endl;  // 输出的是 1 2 3 5 7	return 0;}

Python 程序如下：

#希尔排序
def insert_shell(L):
  #初始化gap值，此处利用序列长度的一般为其赋值
  gap = (int)(len(L)/2)
  #第一层循环：依次改变gap值对列表进行分组
  while (gap >= 1):
  #下面：利用直接插入排序的思想对分组数据进行排序
  #range(gap,len(L)):从gap开始
      for x in range(gap,len(L)):
  #range(x-gap,-1,-gap):从x-gap开始与选定元素开始倒序比较，每个比较元素之间间隔gap
          for i in range(x-gap,-1,-gap):
  #如果该组当中两个元素满足交换条件，则进行交换
              if L[i] > L[i+gap]:
                  temp = L[i+gap]
                  L[i+gap] = L[i]
                  L[i] =temp
  #while循环条件折半
      gap = (int)(gap/2)

时间复杂度和空间复杂度分析：

直接插入排序的时间复杂度为 O(n^2)。因为它要进行两次循环遍历。最好的情况下，表中的元素已经有序，此时，每插入一个元素，都只需要比较一次，而不需要移动元素，所以。时间复杂度为 O（n）。空间复杂度为 O（1）

希尔排序的空间复杂度为 O(1)。时间复杂度的计算依赖于增量序列的函数，这涉及到数学上尚未解决的问题。当 n 在某个特定范围内的时候，时间复杂度约为 O（n^1.3），这也是平均时间复杂度。最坏情况下时间复杂度为 O（n^2）。最好的情况下为 O（n）。

对比分析：

希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小， 插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比o(n^2)好一些。

稳定性分析：

如上一篇博文描述，排序算法的稳定性是指，如果对于一个待排序的序列，里面有相同元素（比如 1 2 3 2 ），那么排序完成以后，第一个 2 仍然会在第二个 2 的前面，即，他们不会交换位置。

对于直接插入排序来说，如果碰到相同的元素，是不交换位置的。所以，直接插入排序是稳定的。

对于希尔排序，需要多次进行直接插入排序，虽然在一次的插入排序中，相同的元素不会发生位置变化。但是，在多次的插入排序中，相同的元素可能在其各自的插入排序中发生位置变化，导致相同元素的最终位置可能发生变化。因此，希尔排序是不稳定的。