【数据结构初阶】--排序(一)：直接插入排序，希尔排序

最新推荐文章于 2025-08-02 19:42:42 发布

原创最新推荐文章于 2025-08-02 19:42:42 发布 · 9.8k 阅读

22 ·

CC 4.0 BY-SA版权

文章标签：

#c语言 #数据结构 #经验分享 #排序算法 #其他

数据结构与算法专栏收录该内容

18 篇文章

订阅专栏

🔥个人主页：@草莓熊Lotso

🎬作者简介：C++研发方向学习者

📖个人专栏： 《C语言》《数据结构与算法》《C语言刷题集》《Leetcode刷题指南》

⭐️人生格言：生活是默默的坚持，毅力是永久的享受。

前言：在前面的学习中，我们实现了顺序表和链表，栈和队列以及二叉树。通过这些知识的学习和实现我们的代码能力也有了一定的提升。那么我们从这篇博客开始就进入到了初阶数据结构最后一个板块，排序的学习。我们会学习多种排序，其实每种排序单独拿出来都不会很难。但是如果让我们自己去实现的话就不是那么容易的了。还是和之前一样，我们先分部分来讲解。

一.排序的概念及应用

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减排列起来的操作。

--我们在日常生活中经常可以见到排序的使用，比如购物平台的筛选排序，还有各种各样的排行榜

常见的排序算法：

--如图所示

二.直接插入排序

基本思想：直接插入排序是一种简单的插入排序法，其基本思想是把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的序列中，直到所有的记录插入完为止，最后得到一个新的有序序列。

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

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

代码实现：

void InsertSort(int* arr, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = arr[end + 1];
		while (end >= 0)
		{
			//升序:>   降序:<
			if (arr[end] > tmp)
			{
				arr[end + 1] = arr[end];
				end--;
			}
			else {
				break;
			}
		}
		arr[end + 1] = tmp;
	}
}

图示如下：

test.c：

#include"Sort.h"

void PrintArr(int* arr, int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

void test1()
{
	int a[] = { 5, 3, 9, 6, 2, 4, 7, 1, 8 };
	int size = sizeof(a) / sizeof(a[0]);
	printf("排序前:");
	PrintArr(a, size);

	//直接插入排序
	InsertSort(a, size);

	printf("排序后:");
	PrintArr(a, size);
}

int main()
{
	test1();
	return 0;
}

--测试完成，打印没有问题，排成了升序，退出码为0

时间复杂度：

O(n^2)

三.希尔排序

基本思想：希尔排序（Shell Sort）是一种改进的插入排序算法，其核心思想是通过将数组分割成若干个“子序列”逐步缩小排序范围，最终实现整体有序。

--先选定⼀个整数（通常是gap = n/3+1），把待排序文件所有记录分成各组，所有的距离相等的记录分在同一组内，并对每⼀组内的记录进行排序，然后gap=gap/3+1得到下⼀个整数，再将数组分成各组，进行插入排序，当gap=1时，就相当于直接插入排序。

希尔排序的特性：

希尔排序是对直接插入排序的优化。
当 gap > 1 时都是预排序，目的是让数组更接近于有序。当 gap == 1 时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。

代码实现：

void ShellSort(int* arr, int n)
{
	int gap = n;
	while(gap>1)
	{ 
		gap = gap / 3 + 1;
		for (int i = 0; i < n - gap; i++)//用i++比用i+=gap省了一个循环
		{
			int end = i;
			int tmp = arr[end + gap];
			
			while (end >= 0)
			{
				//升序:>   降序:<
				if (arr[end] > tmp)
				{
					arr[end + gap] = arr[end];
					end -= gap;
				}
				else {
					break;
				}
			}
			arr[end + gap] = tmp;
		}
	}
}

图示如下：

为啥要用gap=gap/3-1：

test.c：

#include"Sort.h"

void PrintArr(int* arr, int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

void test1()
{
	int a[] = { 5, 3, 9, 6, 2, 4, 7, 1, 8 };
	int size = sizeof(a) / sizeof(a[0]);
	printf("排序前:");
	PrintArr(a, size);

	//希尔排序
	ShellSort(a, size);

	printf("排序后:");
	PrintArr(a, size);
}

int main()
{
	test1();
	return 0;
}

--测试完成，打印没有问题，升序排列正确，退出码为0

时间复杂度：

O(n^1.3)

四.直接插入排序和希尔排序的性能对比

--除了通过时间复杂度以外，我们也可以通过下面这串代码来实现两种排序的性能对比

代码演示：

#include"Sort.h"

void PrintArr(int* arr, int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

void test1()
{
	int a[] = { 5, 3, 9, 6, 2, 4, 7, 1, 8 };
	int size = sizeof(a) / sizeof(a[0]);
	printf("排序前:");
	PrintArr(a, size);

	//直接插入排序
	//InsertSort(a, size);
	//希尔排序
	ShellSort(a, size);

	printf("排序后:");
	PrintArr(a, size);
}

// 测试排序的性能对比
void TestOP()
{
	srand(time(0));
	const int N = 100000;
	int* a1 = (int*)malloc(sizeof(int) * N);
	int* a2 = (int*)malloc(sizeof(int) * N);

	for (int i = 0; i < N; ++i)
	{
		a1[i] = rand();
		a2[i] = a1[i];
	}
	int begin1 = clock();
	InsertSort(a1, N);
	int end1 = clock();

	int begin2 = clock();
	ShellSort(a2, N);
	int end2 = clock();

	printf("InsertSort:%d\n", end1 - begin1);
	printf("ShellSort:%d\n", end2 - begin2);

	free(a1);
	free(a2);
}

int main()
{
	TestOP();
	//test1();
	return 0;
}

--测试完成，可以看出10w个数据排序，希尔排序的用时比直接插入排序少很多(单位：ms)

往期回顾：

【数据结构初阶】--二叉树(四)

【数据结构初阶】--二叉树(五)

【数据结构初阶】--二叉树(六)

结语：本篇博客就到此结束了，主要实现了一下两种插入排序，一个直接插入排序，一个希尔排序。我们通过对比可知希尔排序大部分情况下都是优于直接插入排序的。这里声明一下，博主这里展示的都是Sort.c文件和test.c文件，其中.h文件由于比较简单这里就不展示了，大家可以直接看图片。如果文章对你有帮助的话，欢迎评论，点赞，收藏加关注，感谢大家的支持。