插入排序和希尔排序(详细图解)

前言

希尔排序是插入排序的优化排序，时间复杂度更优。

希尔排序：实际是插入排序中加入gap，进行多组并排，使排序速度得到巨大提升

本文先图解直接插入排序，再重点图解希尔排序

一.插入排序

1.1插入排序的特点

1. 插入排序是一个稳定的排序算法，即相等的元素在排序后保持原有的相对顺序。
2. 在最坏的情况下，即初始序列为逆序的情况下，插入排序需要比较n* (n-1)/2次，而在最好的情况下，也就是初始序列已经有序的情况下，只需进行n-1次比较。
3. 插入排序的工作方式是构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。因此，第k次排序后，前k个元素已经是从小到大排好序的。
4. 插入排序通常采用in-place排序，即只需用到O (1)的额外空间的排序。这意味着在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
5. 插入排序也被称为直接插入排序，它是一种最简单的排序方法，适用于少量元素的排序。然而，需要注意的是，尽管插入排序简单，但其性能可能较差，特别是当输入数据的初始顺序不佳时。
6. 插入排序的时间复杂度是O(n^2).

1.2插入排序示例

1.3插入排序代码

//插入排序
//时间复杂度O(N^2);
//空间复杂度O(1);
void InsertSort(int* a, int n)
{
	assert(a);
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				--end;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}

 1.4插入排序图解

1.4.1单趟插入

 1.4.2多趟插入

二.希尔排序

2.1希尔排序的特点

希尔排序，又称缩小增量排序，是插入排序的改进版本，由D.L.Shell于1959年提出。它的基本思想是将整个待排元素序列分割成若干个子序列，分别进行直接插入排序，然后依次缩减增量再进行排序，直到整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。

希尔排序的主要特点包括：

1. 效率：希尔排序的效率优于普通的插入排序。这是由于希尔排序在一开始就让数据部分有序，从而减少了后续的比较和移动次数。

2. 不稳定：希尔排序是一种不稳定的排序算法，即相等的元素在排序后可能改变原有的相对顺序。

3. 增量递减：希尔排序的另一个重要特点是通过动态定义间隔的方式，对数据进行分组，并逐步减小间隔，直至间隔为1时完成最后一次排序。

4. 空间复杂度：与插入排序相同，希尔排序也是采用in-place排序，即只需用到O (1)的额外空间的排序。

5. 时间复杂度：希尔排序的时间复杂度是O(n^1.3)。

2.2希尔排序代码

//希尔排序
void ShellSort(int* a, int n)
{
	//1.gap>1相当于预排序，让数组接近有序
	//2.gap==1就相当于直接插入排序
	int gap = n;
	while (gap > 1)
	{
		gap = gap / 3 + 1;//+1保证最后一次gap一定是1
		//gap==1最后一次就相当于直接插入排序
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

 2.3希尔排序细节

可以理解为：多组并排

希尔排序分为两个步骤：1.预排序(使用gap);2.直接插入排序

gap越大，前面较大的数据可以快速到达需排序的后面，越不接近有序。

gap越小，越接近有序，当gap=1时，即为插入排序。

不断缩小gap的值进行预排序，即希尔排序的过程。

 2.3希尔排序详细图解

2.4希尔排序详细图解

2.5gap拆分图解

 2.6希尔排序细节图解3

 2.7gap缩小图解

三.插入排序和希尔排序全部代码

#include<stdio.h>
#include<assert.h>
 
 
//插入排序
void InsertSort1(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}
 
 
//希尔排序
void ShellSort1(int* a, int n)
{
	//1.gap>1相当于预排序，让数组接近有序
	//2.gap==1就相当于直接插入排序
	int gap = n;
	while (gap > 1)
	{
		gap = gap / 3 + 1;//+1保证最后一次gap一定是1
		//gap==1最后一次就相当于直接插入排序
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
		
	}
}
 
 
 
void PrintArry1(int* a, int n)
{
	for (int i = 0; i < n; ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}
 
void TestInsertSort()
{
	printf("直接插入排序\n");
	int a[] = {2,7,3,1,5,6,3,2,1,4,9,6,4};
	PrintArry1(a, sizeof(a) / sizeof(a[0]));
	InsertSort1(a, sizeof(a) / sizeof(a[0]));
	PrintArry1(a, sizeof(a) / sizeof(a[0]));
 
}
 
void TestShellSort1()
{
	printf("希尔排序\n");
	int a[] = { 2,7,3,1,5,4,6,8,3,0,12,4,7,3,5,2,7};
	PrintArry1(a, sizeof(a) / sizeof(a[0]));
	ShellSort1(a, sizeof(a) / sizeof(a[0]));
	PrintArry1(a, sizeof(a) / sizeof(a[0]));
}
 
int main()
{
	TestInsertSort();
	TestShellSort1();
	return 0;
}

 3.1运行结果

   以上就是本期内容，欢迎参考指正，如有不懂，欢迎评论或私信出下期！！！