【数据结构】插入排序——直接插入排序 和 希尔排序

直接插入排序 和 希尔排序

一、直接插入排序

我们要如何理解直接插入排序呢?

假设tmp之前的数都被我们拍好了,tmp就是我们要插入的数
让tmp之前的数与tmp进行对比,若比tmp大就将他们向后移动

当遇到比tmp小的数就将tmp插入到该数的后面

这样能保证tmp所在的位置:
前面是比tmp小的数
后面是比tmp大的数

当走完循环就可以完成排序

动图演示:

c 复制代码
//插入排序
void InsertSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		//保存已经拍好序的前 i 个数的下标
		int end = i;

		//保存要插入的数,一会儿会被覆盖
		int tmp = a[i + 1];

		//单次循环
		while (end >= 0 && a[end] > tmp)
		{
			//若前一个数比 tmp 大则将该数填到后面,t--
			a[end + 1] = a[end--];
		}
		a[end + 1] = tmp;
	}
}

我们看到我们这里的循环条件是 i < n - 1

因为当 i 为倒数第二个数时

插入的数为倒数第一个数

代码运行:

二、直接插入排序的弊端

直接插入排序有什么弊端呢?

我们想如果我们要排一个升序

1>

数组中是升序 排列的数:

那么我们每次进入循环都不需要额外进行移动

也就是不用进入循环,移到次数为 0

那么它的时间复杂度是O(N)

2>

数组中是降序 排列的数:

那么我们每次进入循环都要进行移动

并且假设我们要将第 i 个数插入,移动次数为 i - 1

那么它的时间复杂度是O(N ^ 2)

所以直接插入排序的效率是很不稳定的

三、希尔排序

(1)对插入排序的联想

但是插入排序真的不可取吗?

插入排序在最好的情况时间复杂度时O(N)

但是插入排序的效率受到数组原顺序的影响很大

假如要拍一个升序,而最大的数在第一位

那么最大的这个数要移动的次数很多

那么我们想,如果我们可以让插入排序的时间复杂度接近O(N)

那它的效率一定非常高

所以我们想到:

如果我们可以让原来要移动很多次数的数移动的次数变少,就可以提高它的效率

(2)希尔排序的思路

如果我们想让原来要移动次数很多的数,它的移动次数变少

那么我们就要改变它的移动步子大小

我们把步子的这个大小叫gap

我们假设gap = 3

进行一次插入

将 end = i + gap 位置的数插入,使得和 i = 0 位置的数进行交换

最终效果:

我们发现最大的数原先需要 9 次才能移动到最后

但现在仅仅需要三次就到最后了

这样就使我们的排序效率提高

那我们下一次只要从 i = 1 的位置开始

一直到 i < gap

这样就把整个数组进行了初次排序

我们先来分析一次步子大小为 gap 的排序
下面是一次插入的代码:

c 复制代码
//每次跳的步子大小
int gap;
for (int j = 0; j < gap; j++)
{
	//单次排序
	for (int i = j; i < n - gap; i += gap)
	{
		//保存拍好序的前面最后数的下标
		int end = i;

		//保存要插入数的值
		int tmp = a[i + gap];

		//循环
		while (end >= 0 && a[end] > tmp)
		{
			a[end + gap] = a[end];
			end -= gap;
		}
		a[end + gap] = tmp;
	}
}

先看内层:

单次排序 开始

每次将 end = i + gap 处的数插入

与 i = 0 进行比较

随后再将 i += gap

相当于将 end = i + gap + gap 处的数插入

那么在什么时候截止呢?
这时我们要往外层看

我们又进行了一层循环

我们设 j = 0 就是第一次开始插入的位置

为了将整个数组都进行该处理

我们每次将 j++

当 j < gap 时就将 0 到 gap - 1 前的数都处理了

也将整个数组都进行了一次 gap 步的排序

如果不理解可以将上面图中 gap = 3 的情况带入理解

那么我们再反过来看 i 的停止条件

以 gap 等于 3 为例

当 i = 1 或者 i = 2 时

再后面 end = i + gap时,会超出范围

所以当 i < n - gap 时,就可以处理完全部的数

接下来看下面的图:


有没有发现什么,是不是当 gap = 1 时两边的代码就一样了

所以我们接下来就要考虑 gap 的取值了

经过人们的研究,人们发现 gap 每次取 1 / 3 时效率最高

所以就有了下面的代码:

c 复制代码
//希尔排序
void ShellSort(int* a, int n)
{
	int gap = n - 1;
	while (gap != 1)
	{
		//每次跳的步子大小
		gap = gap / 3 + 1;
		for (int j = 0; j < gap; j++)
		{
			//单次排序
			for (int i = j; i < n - gap; i += gap)
			{
				//保存拍好序的前面最后数的下标
				int end = i;

				//保存要插入数的值
				int tmp = a[i + gap];

				//循环
				while (end >= 0 && a[end] > tmp)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				a[end + gap] = tmp;
			}
		}
	}
}

为什么我们要取 gap 时要 gap / 3 + 1

因为当 gap 等于 2 时,再除 3 会等于 0

那么这个 +1 就是为了使 gap 最终会等于 1

动图演示:

四、直接插入排序和希尔排序效率对比

1>随机生成10000个数

让直接插入排序和希尔排序进行比较:

2>我们随机生成100000个数

3>我们随机生成1000000个数


再往后的就不测了,插入排序跑不动了

4>希尔排序的时间复杂度

直接说结论希尔排序的时间时间复杂度为:
O(N ^ 1.3)

很抽象,这个我是不会算,当时听到也感觉惊为天人

但是我们可以探究一下

第一次 gap 我们的最大交换次数

(gap / 3) * 3 此时gap为n

gap / 3 为组数,而 *3是没组最大的交换次数

第二次 gap 我们的最大交换次数

(gap / 3 / 3)* 3 * 3

理应是这样的对吧?

可是要是真的是这样我们第一次不是白处理了嘛

第一次我们已经将要移动次数较多的数移动到后面了

那这个最大交换次数是不可能的

所以就会变得快

相关推荐
dying_man44 分钟前
LeetCode--42.接雨水
算法·leetcode
vortex51 小时前
算法设计与分析 知识总结
算法
艾莉丝努力练剑2 小时前
【C语言】学习过程教训与经验杂谈:思想准备、知识回顾(三)
c语言·开发语言·数据结构·学习·算法
ZZZS05162 小时前
stack栈练习
c++·笔记·学习·算法·动态规划
hans汉斯2 小时前
【人工智能与机器人研究】基于力传感器坐标系预标定的重力补偿算法
人工智能·算法·机器人·信号处理·深度神经网络
vortex53 小时前
算法设计与分析:分治、动态规划与贪心算法的异同与选择
算法·贪心算法·动态规划
前端拿破轮4 小时前
🤡🤡🤡面试官:就你这还每天刷leetcode?连四数相加和四数之和都分不清!
算法·leetcode·面试
地平线开发者4 小时前
征程 6|工具链量化简介与代码实操
算法·自动驾驶
DoraBigHead5 小时前
🧠 小哆啦解题记——谁偷改了狗狗的台词?
算法
Kaltistss5 小时前
240.搜索二维矩阵Ⅱ
线性代数·算法·矩阵