数据结构之各大排序（C语言版）

最新推荐文章于 2024-05-28 21:47:08 发布
最新推荐文章于 2024-05-28 21:47:08 发布
阅读量1.2k 收藏 24
点赞数 23
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79813267/article/details/135328821
版权

我们这里话不多说，排序重要性大家都很清楚，所以我们直接开始。

我们就按照这张图来一一实现吧！

一.直接插入排序与希尔排序.

这个是我之前写过的内容了，大家可以通过链接去看看详细内容。

算法之插入排序及希尔排序（C语言版）-CSDN博客

这里就直接赋上代码了

//直接插入排序(升序)
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 (tmp < arr[end])
			{
				arr[end + 1] = arr[end];
				end--;
			}
			else
			{
				break;
			}
		}
		arr[end + 1] = tmp;
	}
}
//希尔排序(升序)
void Shellsort(int* arr, int n)
{
	int gap = n;
	while (gap > 1)
	{
		gap = gap / 2;
		//gap = gap / 3 + 1;
		//先一组组排好
		//for (int i = 0; i < gap; i++)
		//{
		//	for (int j = i; j < n - gap; j += gap)
		//	{
		//		int end = j;
		//		int tmp = arr[end + gap];
		//		while (end >= 0)
		//		{
		//			if (tmp < arr[end])
		//			{
		//				arr[end + gap] = arr[end];
		//				end-=gap;
		//			}
		//			else
		//			{
		//				break;
		//			}
		//		}
		//		arr[end + gap] = tmp;
		//	}
		//}
		//多组并排
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = arr[end + gap];
			while (end >= 0)
			{
				if (tmp < arr[end])
				{
					arr[end + gap] = arr[end];
					end-=gap;
				}
				else
				{
					break;
				}
			}
			arr[end + gap] = tmp;
		}
	}
}

我们还是分析下他们的时间复杂度吧！

插入排序是通过进行比较来插入的，最坏的情况就是都要比较，所以是O(N^2)，最好情况就是本生就是顺序且有序的。

而希尔排序则不同，大家现在当下只需知道大概在O(1.3N)左右即可

直接插入排序的特性总结：
1. 元素集合越接近有序，直接插入排序算法的时间效率越高
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)，它是一种稳定的排序算法
4. 稳定性：稳定
希尔排序的特性总结：
1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就 会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的比。
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些书中给出的希尔排序的时间复杂度都不固定，大家就记为 O(1.3N)
4. 稳定性：不稳定

二.选择排序

选择排序的思想就是：找到最值的两个数，分别放在首尾，然后再选择次一级的，知道排好。是不是非常简单，所以这里我们上代码：

//选择排序(升序)
void Swap(int* p, int* q)
{
	int* tmp = *p;
	*p = *q;
	*q = tmp;
}
void Selectsort(int* arr, int n)
{
	int begin = 0;
	int end = n - 1;
	while (begin < end)
	{
		int min = begin;
		int max = begin;
		for (int i = begin + 1; i <= end; i++)
		{
			if (arr[i] < arr[min])
				min = i;
			if (arr[i] > arr[max])
				max = i;
		}
		Swap(&arr[begin], &arr[min]);
		//注意：这里一定要留意max的值是不是begin位置，如果是，前一个交换会影响到后一个，所以要找到正确的位置
		if (max == begin)
			max = min;
		Swap(&arr[end], &arr[max]);
		begin++;
		end--;
	}
}
直接选择排序的特性总结：
1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：不稳定

三.堆排序

这个之前也实现过了，可以看链接：

堆排序（C语言版）-CSDN博客

这里还是贴下代码：

void Adjustup(int* arr, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (arr[child] > arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
void Adjustdown(int* arr,int parent, int n)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && arr[child + 1] > arr[child])
		{
			child++;
		}
		if (arr[child] > arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
//堆排序
void Heapsort(int* arr, int n)
{
	//建大堆
	/*for (int i = 1; i < n; i++)
	{
		Adjustup(arr, i);
	}*/
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		Adjustdown(arr,i,n);
	}
	//堆删除
	int end = n - 1;
	while (end > 0)
	{
		Swap(&arr[end], &arr[0]);
		Adjustdown(arr,0, end);
		end--;
	}
}
堆排序的特性总结：
1. 堆排序使用堆来选数，效率就高了很多。
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(1)
4. 稳定性：不稳定

四.冒泡排序和快速排序

这是一个可以说是最简单的排序了，实现的关键就是想好两层循环的条件就行了，我之前也实现过了，大家可以去之前我的文章看看，这里给大家一个链接吧！

冒泡排序即相关想法-CSDN博客

这里直接上代码了，学到这还不会冒泡，建议别在看这个文章了，需要去补就前面的了。

//冒泡排序（升序）
void Bubblesort(int* arr, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		for (int j = 0; j < n - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
				Swap(&arr[j], &arr[j + 1]);
		}
	}
}

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

下面开始我们可以说是非常难的部分了----快速排序

快速排序是 Hoare 于 1962 年提出的一种二叉树结构的交换排序方法，其基本思想为： 任取待排序元素序列中 的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右 子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

我们先直接学hoare版本吧！

注意：hoare的版本是将key取开头的元素

如果我们按照升序排列，我们要先走右边的，这样才能保证相遇的点其值一定比key点的小，原因如下：

相遇分为以下两种情况：

1.左边相遇右边，即右边停止后左边一直走，没有找到比key大的元素直到相遇，而相遇点是右边找小找到的，说明相遇点比key点小（升序）

2.右边相遇左边，即左边停止后右边一直走，没有找到比key小的元素直到相遇，而相遇点是左边找大找到的，说明相遇点比key点大。（降序）

下面我们实现吧！

//快速排序（升序）
void Swap(int* p, int* q)
{
	int* tmp = *p;
	*p = *q;
	*q = tmp;
}
void Quicksort(int* arr, int begin, int end)//注意end到底是啥？如果是元素个数，下面的right要减1，如果是最后一个元素下标，end=right
{
	//递归结束条件
	if (begin >= end)
		return;
	int left = begin;
	int right = end - 1;
	int key = begin;
	while (left < right)
	{
		//先右
		while (left < right && arr[right] >= arr[key])//右找小
		{
			right--;
		}
		//再左
		while (left < right && arr[left] <= arr[key])//左找大
		{
			left++;
		}
		Swap(&arr[left], &arr[right]);
	}
	//相遇点和key交换
	Swap(&arr[left], &arr[key]);
	//第一次完成
	//下面是递归部分
	key = left;
	Quicksort(arr, 0, key);
	Quicksort(arr, key + 1,end);
}

这个就是hoare版本了，学到这你可能会问一下问题：

1.为什么左边要找大，右边要找小？

我们如果要排升序，是不是从小到大的顺序，如果交换的左右不是大和小，那么你确定是在排序

2.key为啥就是数组开头元素呢？

这个其实只是hoare版本的key找法，实际上还有其他方法的，下面我们就讲解下其他key找法。

//三数取中法
int Mid(int* arr,int begin, int end)
{
	int mid = (begin + end-1) / 2;
	if (arr[begin] > arr[end])
	{
		if (arr[mid] > arr[end])
		{
			if (arr[begin] > arr[mid])
				return mid;
			else
				return begin;
		}
		return end;
	}
	else
	{
		if (arr[mid] > arr[begin])
		{
			if (arr[end] > arr[mid])
				return mid;
			else
				return end;
		}
		return begin;
	}
}

对于上面的内容要注意我们都是end表示为最后一个元素是第几个元素，而非所在的数组下标。

下面我们将其改成数组下标，再写一遍hoare版本的快排。

//三数取中法
int Mid(int* arr,int begin, int end)
{
	int mid = (begin + end) / 2;
	if (arr[begin] > arr[end])
	{
		if (arr[mid] > arr[end])
		{
			if (arr[begin] > arr[mid])
				return mid;
			else
				return begin;
		}
		return end;
	}
	else
	{
		if (arr[mid] > arr[begin])
		{
			if (arr[end] > arr[mid])
				return mid;
			else
				return end;
		}
		return begin;
	}
}
void Quicksort(int* arr, int begin, int end)//end表示最后一个元素下标
{
	if (begin >= end)
		return;
	int left = begin;
	int right = end;
	int key = begin;
	while (left < right)
	{
		while (left < right && arr[right] >= arr[key])
			right--;
		while (left < right && arr[left] <= arr[key])
			left++;
		Swap(&arr[left], &arr[right]);
	}
	Swap(&arr[left], &arr[key]);
	key = left;
	Quicksort(arr, 0, key - 1);
	Quicksort(arr, key + 1, end);
}

注意改变之处。

大家可能会发现hoare版本的快排有非常多的点需要注意，于是后人就写出了以下两种不同的写法，对其进行改进。

挖坑法

挖坑法是指先将一个数据储存在数组外面，然后还是右边找小，左边找大，找到就将该位置的数放在原先取出的位置，然后现在的位置即是一个新的坑，一直上述操作直到左右相遇，然后将最开始保存的数据放进相遇位置。

下面我们实现它：

//挖坑法
void partQuicksort(int* arr, int begin, int end)//end表示最后一个元素下标
{
	if (begin >= end)
		return;
	int left = begin;
	int right = end;
	int key = arr[begin];
	int hole = begin;//坑
	while (left < right)
	{
		while (left < right && arr[right] >= key)
			right--;
		arr[hole] = arr[right];
		hole = right;
		while (left < right && arr[left] <= key)
			left++;
		arr[hole] = arr[left];
		hole = left;
	}
	arr[hole] = key;
	partQuicksort(arr, begin, hole - 1);
	partQuicksort(arr, hole + 1, end);
}
前后指针版本 

//前后指针法
void part2Quicksort(int* arr, int begin, int end)//end表示下标
{
	if (begin >= end)
		return;
	int prev = begin;
	int cur = begin + 1;
	int key = begin;
	while (cur <= end)
	{
		if (arr[cur] < arr[key] && ++prev != cur)
		{
			Swap(&arr[prev], &arr[cur]);
		}
		cur++;
	}
	Swap(&arr[prev], &arr[key]);
	key = prev;
	part2Quicksort(arr, 0, key - 1);
	part2Quicksort(arr, key + 1, end);	
}

对于快排还可以优化，例如：我们这里实现时发现，大部分的递归都是在元素非常小的时候，所以如果我们可以将这部分改成其他排序，是不是可以节省一部分空间。

我们以hoare版本为例：

void Quicksort2(int* arr, int begin, int end)//end表示最后一个元素下标
{
	if (begin >= end)
		return;
	//如果元素小于等于10，利用其他排序，这里我们选择插入排序
	if (end - begin + 1 <= 10)
	{
		Insertsort(arr+begin, end - begin + 1);//注意这里数组也要变
	}
	else
	{
		int left = begin;
		int right = end;
		int key = begin;
		while (left < right)
		{
			while (left < right && arr[right] >= arr[key])
				right--;
			while (left < right && arr[left] <= arr[key])
				left++;
			Swap(&arr[left], &arr[right]);
		}
		Swap(&arr[left], &arr[key]);
		key = left;
		Quicksort(arr, 0, key - 1);
		Quicksort(arr, key + 1, end);
	}
}

快排学到现在了，大家是不是觉得自己行了？？？现在我请你实现快排的非递归，请问你如何实现呢？

//快排非递归
int Quicksort3(int* arr, int begin, int end)
{
	//我们这里就用挖坑法实现
	int hole = begin;
	int key = arr[begin];
	while (begin < end)
	{
		while (begin < end && arr[end] >= key)
			end--;
		arr[hole] = arr[end];
		hole = end;
		while (begin < end && arr[begin] <= key)
			begin++;
		arr[hole] = arr[begin];
		hole = begin;
	}
	arr[hole] = key;
	return hole;
}
void QuicksortNone(int* arr, int begin, int end)
{
	SS s1;
	StackInit(&s1);
	StackPush(&s1,begin);
	StackPush(&s1, end);
	while (!StackEmpty(&s1))
	{
		int right = StackTop(&s1);
		StackPop(&s1);
		int left = StackTop(&s1);
		StackPop(&s1);
		int key = Quicksort3(arr, left, right);
		if (left < key - 1)
		{
			StackPush(&s1, left);
			StackPush(&s1,key-1);
		}
		if (right > key + 1)
		{
			StackPush(&s1,key+1);
			StackPush(&s1,right);
		}
	}
	StackDestory(&s1);
}

快速排序的特性总结：
1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(logN)
4. 稳定性：不稳定

五.归并排序

基本思想：
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 
//归并排序
void _Mergesort(int* arr, int begin, int end, int* tmp)
{
	if (begin >= end)
		return;
	//先递归
	int mid = (begin + end) / 2;
	_Mergesort(arr, begin, mid, tmp);
	_Mergesort(arr, mid + 1, end,tmp);
	//并
	int begin1 = begin;
	int end1 = mid;
	int begin2 = mid + 1;
	int end2 = end;
	int i = begin;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (arr[begin1] < arr[begin2])
		{
			tmp[i++] = arr[begin1++];
		}
		else
		{
			tmp[i++] = arr[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		tmp[i++] = arr[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[i++] = arr[begin2++];
	}
	memcpy(arr + begin, tmp + begin, (end - begin + 1)*sizeof(int));
}
void MergeSort(int* arr, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	//检查
	if (tmp == NULL)
	{
		perror(tmp);
		return;
	}
	_Mergesort(arr, 0, n-1, tmp);
	free(tmp);
	tmp = NULL;
}

当然，归并排序也可以非递归实现，由于实现过于复杂，所以我们现在就先不是实现了，以后我们会讲的。

大家加油！

jiaofi
关注
  • 23
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
【数据结构】八大排序！（C语言）
m0_65140642的博客
09-11 604
八大排序！万字手撕！
c语言 数据结构 快速排序算法
04-28
c语言版本的数据结构的快速排序算法，适用于新手学习
[c语言]数据结构 顺序表的实现
CL
04-25 592
首先是main.cpp让我们来看看都有什么函数 #include #include"SeqList.h" using namespace std; int main() { SeqList mylist; InitSeqList(&mylist); int select = 1; ElemType item = 0; ElemType pos
数据结构（c语言版）顺序表的实现
ChunkWen的博客
09-12 1642
数据结构原本的书籍上面只写了算法部分，不能直接运行，在此贴上c语言实现的完整代码，需要注意的地方已在代码中注释 #include <stdio.h> #include <malloc.h> #define LIST_SIZE 100//初始分配空间的节点个数 #define LIST_INCREMENT 10//新分配空间的节点个数 typedef int ElemType; typedef struct book{ ElemType* elem;//存储空间基地址 int
数据结构的希尔排序（c语言版）
最新发布
z6665454的博客
05-28 3008
希尔排序是一种基于插入排序算法的优化排序方法。它的基本思想如下:选择一个增量序列 t1，t2，......，tk，其中 ti > tj, 当 i < j，并且 tk = 1。2.希尔排序的优点时间复杂度较低。希尔排序的时间复杂度一般在 O(n^1.25) 和 O(n^1.5) 之间,优于简单的插入排序。在部分有序的数组中效率很高。希尔排序通过分组插入排序来利用数据的局部有序性,可以有效地加快排序速度。空间复杂度低,只需要常量级的额外空间。代码实现相对简单,易于理解和编码。3.希尔排序的缺点。
数据结构C语言严蔚敏版(第二版)超详细笔记附带课后习题
热门推荐
chongyang_的博客
11-07 26万+
根据此书所做随笔笔记。 一、绪论 1.1、数据机构的研究内容 用计算机解决实际问题时，步骤：首先分析实际问题，从中抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编程，调试，测试。 寻求数据模型的实质是分析问题，从中提取出计算机处理的对象，并找出这些对象之间的关系，然后用数学的语言加以描述。 关键：分析问题中所用到的数据是如何组织的，研究数据之间存在什么样的关系。 由于数据必须在计算机中处理，因此不能局限于数据本身的数学问题的研究，还必须考虑数据的物理结构，即数据在计算机中的存储结构。 1.
数据结构——堆排序（C语言）
櫆溟的博客
11-06 1424
昨天裸考软考，下午有一题就是堆排序。我21年的时候学过堆排序，可到现在全忘光了，结果就是面对那题发呆良久，脑子里始终想不起堆排序的核心流程，真是后悔莫及，现在重新来复习一遍堆排序。
C语言中数据结构之链式基数排序
01-01
C语言中数据结构之链式基数排序 实现效果图： 实例代码： #include #include #include #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 typedef int Status; typedef int ...
C语言-对一个结构体中的字段进行排序
07-12
定义一个数组（学生结构体数组），里面包含学号、姓名、身份证和三科学生成绩，要求写一个函数，根据学生任何一个字段（如学号、姓名、身份证），进行排序。
数据结构实验六排序c语言
04-25
数据结构实验六排序C语言 数据结构是计算机科学中的一门重要学科，它研究如何组织和存储数据，以便高效地使用和处理数据。排序是数据结构中的一种基本操作，目的是将一组数据按某种顺序排列，以便更好地存储和处理...
数据结构各章节算法实现（C语言版）.docx
10-12
本资料《数据结构各章节算法实现（C语言版）》提供了详细的数据结构算法实现，采用C语言编写，适合计算机专业的学生、ACM竞赛参与者、考研复习者以及准备面试笔试的人群使用。以下是对各个章节主要算法的详细说明： ...
《数据结构》（C语言版）教程
10-14
《数据结构》（C语言版）教程是一门深入学习计算机科学与技术不可或缺的重要课程，它主要探讨如何在计算机中组织和存储数据，以便高效地访问和处理这些数据。本教程结合了C语言这一强大而灵活的编程语言，使得学生...
C语言数据结构——顺序表结构及算法
heihutaotie的博客
06-29 436
C语言数据结构——顺序表 #include<stdio.h>// 引入头文件 #define ListSize 100//定义表长为100 typedef int DataType;//定义一种int类型的类型符DataType typedef struct{ //定义一种结构体类型 DataType Data[ListSize];//定义一种int类型的数组，长度为100 int length;//定义长度 }SeqList;//新定义的结构类型名为SeqList void Ini
C语言:将结构体数组的成绩按照从小到大进行排序。
dienangpiao2051的博客
08-03 2080
#include<stdio.h> typedef struct student { char *name; int sno; int age; float score; }Student; void sortScore(Student st[],int len) { int flag = 0; for(int i=0;i<len...
C语言实现数组从大到小排序
XXT2018的博客
03-14 2万+
使用C语言实现数组 3,7,9,11,0,6,7,5,4,2 从大到小排序 #include<stdio.h> void reserve(int x[], int n); //函数声明 void main (){ int a[10] = {3,7,9,11,0,6,7,5,4,2}; //要排序的数组元素 int i; for (i = 0; i < 10; i++)...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

jiaofi

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值