数据结构(初阶7)---七大排序法(堆排序，快速排序，归并排序，希尔排序，冒泡排序，选择排序，插入排序)(详解)

Mr__vantasy2024-11-28 9:58

排序

  • 1.插入排序
  • 2.希尔排序
  • 3.冒泡排序
  • 4.选择排序(双头排序优化版)
  • 5.堆排序
  • 6.快速排序
    • 1). 双指针法
    • 2).前后指针法
    • 3).非递归法
  • 7.归并排序
    • 1).递归版本(递归的回退就是归并)
    • 2).非递归版本(迭代版本)

计算机执行的最多的操作之一就有排序，排序是一项极其重要的技能

接下来我们来详细介绍一下，我们遇到最多的排序方法

1.插入排序

首先我们介绍的是最基本的排序方式，插入排序

给定一个数组
[2,3,5,7,6,4,1]

代码实现：如何在数组中实现插入呢，

1.先将p+1的值记住。

2.从后向前遍历，找到比它小的前一个数

3.在遍历的时候，只需要将后面的值赋值给前面的值

c 复制代码 
void insertsort(int* a, int n)
{
	for (int count = 0; count < n; count++)
	{
		int end = count;
		int tmp = a[count+1];
		while (end >= 0)
		{
			if (a[end] > tmp)
			{
				a[end+1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end+1] = tmp;
	}

}

这是最基本的排序方式

遍历了n+(n-1)+(n-2)+...+1

共计时间复杂度为O(n^2);

2.希尔排序

希尔排序是插入排序的升级版 ，是一种强大的排序方式。

我们发现如果我们正常使用选择排序，如果我的极值在数组的两头 ，我们就需要花费更多的时间将两头的元素一步一步的移到另一端 ，所以希尔大佬就发明了一种跳跃式移动的方法------希尔排序

给定一个数组：[5,3,2,4,1,2,2,3,4]需要排为升序

所以我们可以去迭代gap，让gap从sz/3开始逐渐向1迭代，
这样数列逐渐有序->最终变为有序

c 复制代码 
void ShellSort(int*a,int n)
{
	int gap=n;
	while (gap > 1)
	{
		gap = gap / 3 + 1;
		for (int count = 0; count < n - gap; count++)
		{
			int end = count;
			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;
		}

	}
}

在实际应用中，希尔排序的平均时间复杂度通常被认为是
O(n log n)到O(n^(1.2)) 之间

3.冒泡排序

冒泡排序应该是所有初学者第一次学习的排序算法，也是效率最低的一种算法

这里就不过多赘述

通过一次次的冒泡排序，每一次都将一个数字移到正确的位置

c 复制代码 
void swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void bubblesort(int *p,int sz)
{
	for (int count = 0; count < sz; count++)
	{
		for (int cur = 0; cur < sz - count-1; cur++)
		{
			if (p[cur] > p[cur+1])
			{
				swap(p + cur, p + cur + 1);
			}
		}
	}
}

4.选择排序(双头排序优化版)

选择排序应该也是一种十分常见的排序方式

这里我们就在原有基础上优化升级一下，双头选择排序优化版

从两头分别取数，左边取一个交换为较小，右边取一个交换为较大

给定一个数组：[5,3,2,4,1,2,2,3,4]需要排为升序

时间复杂度还是O(n^2)但是效率要略高一些。

5.堆排序

堆排序我已经在这篇文章中仔细地阐述了：

可以点击以下链接去访问:

数据结构(初阶5)---堆与堆排序(详解)

6.快速排序

运用最最广泛的一种排序方式，以其独特的解决思想而闻名。

他的变种和相关推论有许多，这边着重将双指针法 ，前后指针法

优化方式为三数取中法

快速排序的本质就是分治的思想，递归的思想

给定一个数组：[5,3,2,4,1,2,2,3,4]需要排为升序

1). 双指针法

为什么我们必须让p1先走呢，因为p1先走，最后相遇的时候，

相遇的值一定大于key，可以直接将key与相遇值交换
我们也许会想到 ，如果key的左边全部都大于key，这种极端的情况下，我们的快排就会变得十分的不稳定

所以我们有一个三数取中的优化方法

先将key与中间值与排头比较，最后将第二大的值与key的位置交换

c 复制代码 
void swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
int mid_inthree(int* arr, int begin, int end)
{
	if (arr[begin] > arr[end] && arr[begin] < arr[(begin + end) / 2])
		return begin;
	else if (arr[end] > arr[begin] && arr[end] < arr[(begin + end) / 2])
		return end;
	else
		return (end + begin) / 2;
}
void my_qsort(int* arr, int begin, int end)//双指针快排
{
	if (end <= begin)
	{
		return;
	}
	swap(arr+end, arr+mid_inthree(arr, begin, end));
	int left = begin, right = end - 1;
	while (left <= right)
	{
		while (arr[left] <= arr[end]&&left<=right)
		{
			left++;
		}
		while (arr[right] >= arr[end]&&right>=left)
		{
			right--;
		}
		if (left < right)
		{
			swap(arr + left, arr + right);
		}
	}
	swap(arr + end, arr + left);
	my_qsort(arr, begin, left - 1);
	my_qsort(arr, left + 1, end);
}

2).前后指针法

c 复制代码 
void swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
int mid_inthree(int* arr, int begin, int end)
{
	if (arr[begin] > arr[end] && arr[begin] < arr[(begin + end) / 2])
		return begin;
	else if (arr[end] > arr[begin] && arr[end] < arr[(begin + end) / 2])
		return end;
	else
		return (end + begin) / 2;
}
void my_qsort2(int* arr, int begin, int end)
{
	if (end <= begin)
	{
		return;
	}
	swap(arr + end, arr + mid_inthree(arr, begin, end));
	int cur = begin, prev = begin-1;
	while (cur<end)
	{
		while (cur < end && arr[cur] >= arr[end])
		{
			cur++;
		}
		prev++;
		swap(arr + cur, arr + prev);
	}
	swap(arr + prev+1, arr + end);
	my_qsort(arr, begin, prev - 1);
	my_qsort(arr, prev + 1, end);
}

3).非递归法

递归的短板不言而喻，稍微大一点的数组就会导致栈溢出

所以我们这里可以在堆上面建立一个模拟栈，总所周知栈上空间只有M量级 ，堆上空间却有G量级

大致思路与上面类似，只是多了一个模拟栈 ，所以选择上面任意一种排序法就行，这里选择双指针快排作为核心
我们的模拟栈的作用是什么：用来存放和调用下标

比如说给定一个数组：[5,3,2,4,1,2,2,3,4]需要排为升序

哪么我的模拟栈中存入 (0,8)这两个区间的脚标

每进行一次快排，去掉内部的两个脚标，再放入四个脚标；

如果区间只有一个数字，就不放入模拟栈

最后栈变为空。

所以代码实现如下：

c 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// 定义栈节点
typedef int STDataType;

typedef struct Stack {
    STDataType _data;
    struct Stack* _next;
} Stack;

// 初始化栈
Stack* StackIni() {
    return NULL; // 空栈直接用 NULL 表示
}

// 销毁栈
void Stackdestory(Stack* pst) {
    while (pst) {
        Stack* tmp = pst;
        pst = pst->_next;
        free(tmp);
    }
}

// 入栈
void StackPush(Stack** ppst, STDataType x) {
    Stack* newNode = (Stack*)malloc(sizeof(Stack));
    newNode->_data = x;
    newNode->_next = *ppst; // 新节点指向当前栈顶
    *ppst = newNode;        // 更新栈顶为新节点
}

// 出栈
void StackPop(Stack** ppst) {
    assert(*ppst); // 确保栈非空
    Stack* tmp = *ppst;
    *ppst = (*ppst)->_next;
    free(tmp);
}

// 判断栈是否为空
int Stackempty(Stack* pst) {
    return pst == NULL; // 空栈返回 1，非空返回 0
}

// 获取栈顶元素
STDataType Stacktop(Stack* pst) {
    assert(!Stackempty(pst)); // 确保栈非空
    return pst->_data;
}

前面是栈的源码操作，和建立

下面实现非递归快排

c 复制代码 
void swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
int partsort(int* arr, int begin, int end)//双指针核心
{
	swap(arr + end, arr + mid_inthree(arr, begin, end));
	int left = begin, right = end - 1;
	while (left <= right)
	{
		while (left <= right&&arr[left] <= arr[end])
		{
			left++;
		}
		while (right >= left &&arr[right] >= arr[end] )
		{
			right--;
		}
		if (left < right)
		{
			swap(arr + left, arr + right);
		}
	}
	swap(arr + end, arr + left);
	return left;
}
void my_qsort3(int* arr, int begin, int end)//非递归快排
{
	Stack* tmp=StackIni();
	StackPush(&tmp, end);
	StackPush(&tmp, begin);
	while (!Stackempty(tmp))
	{
		int begin = Stacktop(tmp);
		StackPop(&tmp);
		int end = Stacktop(tmp);
		StackPop(&tmp);
		int div = partsort(arr, begin, end);
		
		if (div + 1 < end)
		{
			StackPush(&tmp, end);
			StackPush(&tmp, div+1);

		}
		if (div - 1 > begin)
		{
			StackPush(&tmp, div - 1);
			StackPush(&tmp, begin);
		}
	}
	Stackdestory(tmp);
}

这种操作可以有效规避栈溢出，但是不会提高性能。

用了三数取中的方法，我们的快排可以近似为O(nlogn)

7.归并排序

归并排序也是一个十分重要的排序，在许多场景下都有运用，其主要思想是分治

给定一个数组：[5,3,2,4,1,2,2,3]需要排为升序

主要思想如下：
递归到底，再向上归并

1).递归版本(递归的回退就是归并)

代码实现如下，在经历了二叉树便利的学习后，归并排序的代码其实并不难理解

c 复制代码 
void _MergeSort(int* a, int left, int right, int* tmp)//递归回退就是归并
{
	if (left >=right)
	{
		return;
	}
	int mid = (left+right) / 2;
	_MergeSort(a, left, mid,tmp);
	_MergeSort(a, mid + 1, left, tmp);
	int begin_1 = left, end_1 = mid;
	int begin_2 = mid + 1, end_2 = right;
	int begin_tmp = begin_1;
	while (begin_1 <= end_1 && begin_2 <= end_2)
	{
		if (a[begin_1] >= a[begin_2])
		{
			tmp[begin_tmp++] = a[begin_2++];
		}
		else 
		{
			tmp[begin_tmp++] = a[begin_1++];
		}
	}
	while (begin_1 <= end_1)//因为是不等长的，所以我们需要考虑不等长的情况
	{
		tmp[begin_tmp++] = a[begin_1++];
	}
	while (begin_2 <= end_2)
	{
		tmp[begin_tmp++] = a[begin_2++];
	}
	while (left <= end_2)//复制过去
	{
		a[left] = tmp[left];
		left++;
	}
}
void MergeSort(int* arr, int n)
{
	assert(arr);
	int* tmp = (int*)malloc(sizeof(int) * n);
	_MergeSort(arr,0,n-1,tmp);
}

2).非递归版本(迭代版本)

这个版本有点抽象 ,这种递归改非递归的题都很让人摸不着头脑qwq

创建数组int arr[ ] = {1,3,5,7,9,2,4,6,8,0};

我们创造一个gap，gap从1开始，为 2^(n-1)+1,这样代表1，3，7，15...刚好表示

代码实现：(切记要控制边界，且要处理特殊情况！！！)

c 复制代码 
void MergeSortpart(int* a, int left,int mid,int right, int* tmp)
{
	int begin_1 = left, end_1 = mid;
	int begin_2 = mid + 1, end_2 = right;
	int begin_tmp = begin_1;
	while (begin_1 <= end_1 && begin_2 <= end_2)
	{
		if (a[begin_1] >= a[begin_2])
		{
			tmp[begin_tmp++] = a[begin_2++];
		}
		else
		{
			tmp[begin_tmp++] = a[begin_1++];
		}
	}
	while (begin_1 <= end_1)//因为是不等长的，所以我们需要考虑不等长的情况
	{
		tmp[begin_tmp++] = a[begin_1++];
	}
	while (begin_2 <= end_2)
	{
		tmp[begin_tmp++] = a[begin_2++];
	}
	while (left <= right)//复制过去
	{
		a[left] = tmp[left];
		left++;
		//printf("%d ", a[left]);
	}
}
void MergeSort(int* arr, int n)
{
	assert(arr);
	int* tmp = (int*)malloc(sizeof(int) * n);
	//_MergeSort(arr,0,n,tmp);
	int gap = 1;
	for (gap = 1; gap <= n-1; gap=gap*2+1)
	{
		for (int x = 0; x+gap<=n; x += gap+1)
		{
			int begin_1 = x, end_1 = x + gap;
			int mid = (begin_1 + end_1) / 2;
			MergeSortpart(arr, begin_1,mid,end_1,tmp);
		}
		for (int i = 0; i < n + 1; i++)
		{
			printf(" %d", arr[i]);
		}
		printf("\n");
	}

	if (gap/2 != n-1)//处理后面多出来的一小块
	{
		MergeSortpart(arr, 0, gap/2, n,tmp);
	}
	//_MergeSort(arr,0,n-1,tmp);
}

(*´∀`)~♥

创作不易，恳请留一个赞吧qwq，有留言必回 (*´∀`)~♥

相关推荐
倔强的石头1065 分钟前
【C++经典例题】求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句
开发语言·c++
九离十8 分钟前
C语言教程——指针进阶（1）
c语言·开发语言
Channing Lewis9 分钟前
经典编程题：服务器广播
python·算法
DevOpsDojo12 分钟前
Julia语言的软件工程
开发语言·后端·golang
编程|诗人18 分钟前
Kotlin语言的数据结构
开发语言·后端·golang
Ritsu栗子28 分钟前
代码随想录算法训练营day27
c++·算法
小冯的编程学习之路28 分钟前
【LeetCode】：稀疏相似度【困难】
c++·算法·leetcode
羊小猪~~36 分钟前
C/C++语言基础--C++STL库算法记录(质变算法、非质变算法、查找、排序、排列组合、关系算法、集合算法、堆算法等)
c语言·开发语言·数据结构·c++·算法·stl
qystca38 分钟前
炸弹 (boom.c)（100分双端递推+分割线优化）
算法
2401_898410691 小时前
JavaScript语言的学习路线
开发语言·后端·golang
热门推荐
01图像分割：Pytorch实现UNet++进行医学细胞分割02半导体应用系统一些小知识收集(strip&wafer mapping,EAP&scada)03HCIA-datacom数通题库和录播视频资料04ESP-IDF学习记录（4） ESP-IDF examples目录05渗透测试之SQLMAP工具详解 kali自带SQLmap解释 重点sqlmap --tamper 使用方式详解 搞完你就很nice了06优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间07如何在 Ubuntu 22.04 上安装并开始使用 RabbitMQ08新手学习VR全景需要知道的几个问题09校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站10密码学原理技术-第六章-introduction to pulibc-key cryptography