直接插入排序，希尔排序（C实现）看不懂来砍我

一些基本概念，上篇博客已经介绍了，什么是排序，时间复杂度，空间复杂度等等概念，详情请看上篇博客。

一，直接插入排序

思想：

把待排序的记录，按其关键码值的大小，逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。

实际中我们玩扑克牌时，就用了插入排序的思想

当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与 array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移。

任何排序都要会，单趟排序。先写单趟情况，在数组【0，end】中当插入一个数时，要在原数组有序的情况下比较大小，如果比最后一个小，--end，把end赋值给end+1，再往前比较，

以此类推，就算是比第一个数还小，也没关系，--end之后end到了数组的-1位置，最后把tem赋值给end+1，也就是数组的0，第一个位置。

        int end ;
		int tem = a[end + 1];
		while (end >= 0)
		{
			if (a[end] > tem)
			{
				a[end + 1] = a[end];
				--end;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tem;

 

按照上面代码，单趟效果，例如，9，5，8，4，3，

单趟之后变成，5，9，8，4，3，

下面是整体排序，完整的代码。

void InsertSort(int* a, int n)      //直接插入排序
{
	
	for (int i = 0;i < n-1; ++i)
	{
		int end = i;
		int tem = a[end + 1];
		while (end >= 0)
		{
			if (a[end] > tem)
			{
				a[end + 1] = a[end];
				--end;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tem;
	}
}

 

照上面代码，整体效果，例如，9，5，8，4，3，

一，5，9，8，4，3，

二，5，8，9，4，3，

三，4，5，8，9，3，

四，3，4，5，8，9

直接插入排序的特性总结：

1. 元素集合越接近有序，直接插入排序算法的时间效率越高

2. 时间复杂度：O(N^2)

3. 空间复杂度：O(1)，它是一种稳定的排序算法

4. 稳定性：稳定

二，希尔排序

希尔排序法又称缩小增量法。希尔排序法的基本思想是：

先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。

1. 选择一个增量序列，通常以2为倍数逐渐减小，直至为1。
2. 根据选定的增量序列，将待排序数组分成若干组。
3. 对每组进行插入排序。
4. 逐步缩小增量序列，重复步骤2和3，直至增量为1，完成最后一次插入排序。

    [0-end]插入end+gap，[0,end+gap]有序，---间隔为gap的数据

void ShellSort(int* a, int n)
{
	int gap=3;
	for (int j = 0; j < gap; ++j)
	{
		for (int i = j; i < n - gap; i += gap)
		{

			//[0-end]插入end+gap[0,end+gap]有序，---间隔为gap的数据
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (a[end] > tmp)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

优化改进版

//优化版

void ShellSort1(int* a, int n)
{
	int gap = 3;
	
	
		for (int i = 0; i < n - gap; ++i)  //齐头并进的，优化一点
		{

			//[0-end]插入end+gap[0,end+gap]有序，---间隔为gap的数据
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (a[end] > tmp)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	
}

就是特殊的直接插入排序，把gap换成1 ，你们看看是不是上面的插入排序

1，复杂度上的表现为时间复杂度为 O(n^2) 到 O(n*logn) 不等。

2，空间复杂度为 O(1)

3，稳定性：不稳定，，即相同元素的相对位置在排序前后可能发生变化。