数据结构（C语言）八大排序

最新推荐文章于 2024-07-31 13:43:08 发布
最新推荐文章于 2024-07-31 13:43:08 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： 数据结构（C语言） 文章标签： c++ 动态规划 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mu_Muxi_/article/details/121567411
版权

排序
1.算法描述
2.代码实现
3.效率分析(时间复杂度,空间复杂度,稳定性)

稳定性:针对关键字相同的数据(相同的数字),排序前如果A在A’的前面,排完序后还能保证A在A’的前面,则算法稳定,否则不稳定
通俗的来讲就是不跳跃的交换数据就是稳定的

目录

1.插入排序

也叫简单插入排序或者直接插入排序
算法描述:从当前位置开始,从后往前找比当前数字小的,插入到这个小的数字后面;
在找的过程中, 如果发现一个比当前数字大的, 同时将这个数字往后挪动
特点:数据越有序越快,完全有序则为O(n)

//插入排序
void InsertSort(int* arr, int len)//O(n^2),O(1)
{
	//没有跳跃式的交换数据,所以是稳定的
	int tmp;
	int j;
	for (int i = 1; i < len; i++)//i是当前需要处理的数字的下标
	{
		tmp = arr[i];
		for (j = i - 1; j >= 0; j--)//从后往前找位置,找比当前数字小的,同时移动数据
		{
			if (arr[j] > tmp)//该数据需要后移
			{
				arr[j + 1] = arr[j];
			}
			else
			{
				//arr[j + 1] = tmp;
				break;
			}
		}
		arr[j+1] = tmp;
	}
}

2.希尔排序

直接插入排序越有序越快是希尔排序的一个理论基础

算法描述:间隔式分组,利用直接插入排序排序让组内有序;缩小分组再排序;直到缩为1组,完全有序

//一趟希尔排序,gap为组数(间隔)
//不稳定,因为有跳跃式的交换数据
//时间复杂度:O(n^1.3~1.5)  空间复杂度O(1)
static void Shell(int* arr, int len, int gap)
{
	int tmp;
	int j;
	for (int i = gap; i < len; i++)//从"第二个"数据开始
	{
		tmp = arr[i];
		for (j = i - gap; j >= 0; j -= gap)
		{
			if (arr[j] > tmp)
			{
				arr[j + gap] = arr[j];
			}
			else
			{
				break;
			}
		}
		arr[j + gap] = tmp;
	}
}
void ShellSort(int* arr, int len)
{
	int d[] = { 5,3,1 };
	for (int i = 0; i < sizeof(d) / sizeof(d[0]); i++)
	{
		Shell(arr, len, d[i]);
	}
}

3.冒泡排序

算法描述：两两比较(相邻),大的往后走

void BubbleSort(int* arr, int len)//O(n^2),O(1),稳定
{
	int tmp;
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j + 1 < len - i; j++)//小心j+1越界
		{
			if (arr[j] > arr[j + 1])
			{
				tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

4.快速排序

找到一个基准(第一个数据)
1.从后往前找比基准小的数据往前移动
2.从前往后找比基准大的数据往后移动,
3.重复1、2直到找到基准.
最大的缺点:
越有序越慢,完全有序O(n^2).
空间复杂度大,是O(long n)
不稳定

递归写法

//快速排序(考试重点)

//一次划分,考试的重点
int Partition(int* arr, int low, int high)//O(n),O(1),不稳定
{
	int tmp = arr[low];//基准
	while (low < high)
	{
		while (low<high && arr[high] >= tmp)
			high--;
		arr[low] = arr[high];
		while (low < high && arr[low] <= tmp)
			low++;
		arr[high] = arr[low];
	}
	arr[low] = tmp;
	return low;
}

void Quick(int* arr, int low, int high)
{
	int par = Partition(arr, low,high);
	if(low < par-1)//保证前面至少有两个数字
	{
		Quick(arr, low, par - 1);
	}
	if (par + 1 < high)
	{
		Quick(arr,par+1,high);
	}
}

//快速排序
void QuickSort(int* arr, int len)//O(nlogn),O(logn),不稳定,越有序越慢
{
	Quick(arr,0,len-1);
}

非递归写法

//非递归的快速排序
void QuickSort1(int* arr, int len) 
{
	//创建一个栈,用于存放每个划分段的起始和结尾下标
	int* index = (int*)malloc(len*sizeof(int));//不好,可以使用STL中的stack
	assert(index != NULL);
	int top = 0;//栈顶指针,当前可以存放数据的下标
	int low;//起始下标
	int high;//结尾下标
	//先入起始下标,再如结尾下标
	index[top++] = 0;
	index[top++] = len - 1;
	while (top > 0)//栈不空
	{
		//先出结尾下标,再出起始下标
		high = index[--top];
		low = index[--top];
		int par = Partition(arr,low,high);
		//如果左边超过一个数据,需要继续入栈
		if (low < par - 1)//先入起始下标,再如结尾下标
		{
			index[top++] = low;
			index[top++] = par-1;
		}
		//如果右边超过一个数据,需要继续入栈
		if (par + 1 < high)
		{
			index[top++] = par + 1;
			index[top++] = high;
		}
	}
	free(index);
}

5.选择排序

每次都从待排序中找到最小值和待排序的第一个交换

void SelectSort(int* arr, int len)//O(n^2),O(1),不稳定
{
	int tmp;
	int minIndex;//最小值的下标
	for (int i = 0; i < len - 1; i++)
	{
		minIndex = i;
		for (int j = i + 1; j < len; j++)
		{
			if (arr[minIndex] > arr[j])
			{
				minIndex = j;
			}
		}
		if (minIndex != i)
		{
			tmp = arr[minIndex];
			arr[minIndex] = arr[i];
			arr[i] = tmp;
		}
	}
}

6.堆排序

//父-->子:i--->2*i+1,2*i+2
//子-->父:i--->(i-1)/2
//堆调整
void HeapAdjust(int* arr, int start, int end)//O(log n)
{
	int tmp = arr[start];
	for (int i = 2 * start + 1; i <= end;i=2*i+1)
	{
		if (i < end && arr[i] < arr[i + 1])//有右孩子,并且左孩子的值小于右孩子的值
		{
			i++;
		}//i一定是左右孩子的最大值
		if (arr[i] > tmp)
		{
			arr[start] = arr[i];
			start = i;
		}
		else
		{
			break;
		}
	}
	arr[start] = tmp;
}
//堆排序
void HeapSort(int* arr, int len)//O(nlogn),O(1),不稳定
{
	int i;
	//建立大根堆,从后往前,多次调整
	for ( i = (len - 1 - 1) / 2; i >= 0; i--)//O(nlogn)
	{
		HeapAdjust(arr, i, len - 1);
	}
	//每次都将根和待排序的最后一个交换,然后再调整
	int tmp;
	for (i = 0; i < len - 1; i++)//O(nlogn)
	{
		//交换
		tmp = arr[0];
		arr[0] = arr[len - 1 - i];
		arr[len - 1 - i] = tmp;

		HeapAdjust(arr, 0, len - 1 - i - 1);
	}
}

7.归并排序

将两段有序的数据合并成一段有序的数据,直到所有的数据有序(2路归并)

//一次归并,gap为归并段的长度
static void Merge(int* arr, int len, int gap)//O(n),一次归并的时间复杂度
{
	int low1 = 0;
	int high1 = low1 + gap - 1;
	int low2 = high1 + 1;
	int high2 = low2 + gap  < len?low2+gap-1:len-1;

	int* brr = (int*)malloc(len * sizeof(int));
	assert(brr != NULL);

	int i = 0;//brr的下标
	//有两个归并段
	while (low2<len)
	{
		//两个归并段还有数据,需要比较
		while (low1 <= high1 && low2 <= high2)
		{
			if (arr[low1] <= arr[low2])
			{
				brr[i++] = arr[low1++];
			}
			else
			{
				brr[i++] = arr[low2++];
			}
		}
		
		//一个归并段已经完成,另一个还有数据
		while (low1 <= high1)
		{
			brr[i++] = arr[low1++];
		}
		while (low2 <= high2)
		{
			brr[i++] = arr[low2++];
		}
		//下两个归并段(四个变量往后走)
		low1 = high2 + 1;
		high1 = low1 + gap - 1;
		low2 = high1 + 1;
		high2 = low2 + gap < len ? low2 + gap - 1 : len - 1;
	}

	//只有一个归并段
	while (low1 < len)
	{
		brr[i++] = arr[low1++];
	}

	//将归并好的数据拷贝到arr里
	for (i = 0; i < len; i++)
	{
		arr[i] = brr[i];
	}
	free(brr);
}
//归并排序
void MergeSort(int* arr, int len)//O(nlogn),O(n),稳定
{
	for (int i = 1; i < len; i*=2)
	{
		Merge(arr, len, i);//一次归并
	}
}

8.基数排序

带头文件"lqueue.h"

static int GetFigur(int* arr, int len)
{
	int max = arr[0];
	for (int i = 0; i < len; i++)
	{
		if (max < arr[i])
		{
			max = arr[i];
		}
	}
	int count = 0;
	while (max != 0)
	{
		count++;
		max /= 10;
	}
	return count;
}

//获取十进制整数右数第figur位的数字,figur从0开始
//例如(123,0)-->3  (123,1)-->2  (123,2)-->1  (123,3)-->0
static int GetNum(int n, int figur)
{
	for (int i = 0; i < figur; i++)
	{
		n /= 10;
	}
	return n % 10;
}
//基数排序
void RadixSort(int* arr, int len)//O(d*n),O(n),稳定
{
	HNode queArr[10];
	for (int i = 0; i < 10; i++)
	{
		InitQueue(&queArr[i]);
	}
	//得到最大数字的位数,确定进队和出队的趟数
	int count = GetFigur(arr, len);
	int index;
	for (int i = 0; i < count; i++)//处理每个数字从右往左的第i个数
	{
		for (int j = 0; j < len; j++)//遍历数组并入队
		{
			index = GetNum(arr[j], i);
			Push(&queArr[index], arr[j]);//将数字放入到对应的队列
		}
		//依次出队
		int j = 0;
		for (int k = 0; k < 10; k++)
		{
			while (!IsEmpty(&queArr[k]))
			{
				Pop(&queArr[k], &arr[j++]);
			}
		}
	}

	for (int i = 0; i < 10; i++)
	{
		Destroy(&queArr[i]);
	}
}

第"9"个排序:链表排序

1.单链表存放数据时我们用什么排序?(冒泡,选择排序)
2.双向链表存放数据我们用什么排序?(快速排序,STL中的list为双向链表)

测试

void Show(int* arr, int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	int arr[] = { 34,2,0,15,78,90,45,67,1234 };
	//SelectSort(arr, sizeof(arr) / sizeof(arr[0]));
	//HeapSort(arr, sizeof(arr) / sizeof(arr[0]));
	MergeSort(arr, sizeof(arr) / sizeof(arr[0]));
	//int count = GetFigur(arr, sizeof(arr) / sizeof(arr[0]));
	//printf("count==%d\n", count);
	//RadixSort(arr, sizeof(arr) / sizeof(arr[0]));
	Show(arr, sizeof(arr) / sizeof(arr[0]));
	return 0;
}
木木夕 _
关注
专栏目录
【数据结构】八大排序！（C语言）
m0_65140642的博客
09-11 616
八大排序！万字手撕！
数据结构（C语言版） 第八章 排序 知识梳理 + 习题详解1
08-03
本文将深入讲解C语言版《数据结构》第八章中涉及的排序算法，包括归并排序、交换排序（快速排序和冒泡排序）、插入排序、选择排序以及它们之间的比较。 一、归并排序 归并排序是一种分治策略的体现，它将大问题分解...
数据结构——八大排序算法c语言实现
qq_33431840的博客
05-13 548
数据结构——八大排序算法c语言实现 插入，希尔，选择，冒泡，堆排，快排，归并，计数 c语言实现，并分析其时间，空间复杂度以及稳定性 #include<stdio.h> #include<stdlib.h> #include"Sort.h" #include<memory.h> void Swap(int* array, int i, int j){ int tmp=array[i]; array[i]=array[j]; array[j]=tmp; } //插入
数据结构——排序(C语言版)
最新发布
2301_80894970的博客
07-31 946
a[hole] = a[left]：将找到的大于基准值的元素移到之前坑洞的位置，即hole所指向的位置。这样，prev指向的是当前已经处理好的小于基准值的部分的最后一个元素的位置。希尔排序法的基本思想是：先选定⼀个整数（通常是gap = n/3+1），把 待排序⽂件所有记录分成各组，所有的距离相等的记录分在同⼀组内，并对每⼀组内的记录进⾏排序，然后gap=gap/3+1得到下⼀个整数，再将数组分成各组，进⾏插⼊排序，相当于在插入排序之前对原数据进行一个预排序，当gap=1时就相当于 直接插⼊排序。
数据结构（C语言）-排序
czh2637750821的博客
04-03 1025
排序一、排序的基本概念二、插入排序1、有序插入方法2、直接插入排序2、折半插入排序3、希尔排序( Shell's Sort )三、交换排序1、冒泡排序 ( Bubble Sort )2、快速排序四、选择排序1、简单选择排序2、堆排序五、各种排序算法比较 一、排序的基本概念 为了查找方便，通常希望查找表是按关键字有序排序的，因此学习和研究各种排序的方法和对应的算法，有助于提高计算机对数据处理的工作效率。首先了解一些和排序相关的概念。 1.排序( Sorting ) 将数越元素(或记录)的任意序列，重新排列成
数据结构（c语言版）（排序）
cornerlin的博客
04-27 207
直接插入排序示例： 一趟快排序过程示例： 第一次查找交换： 从high向前查找小于data[0].key的记录，得到结果： 从low向后查找大于data[0].key的记录，得到结果： 第二次查找交换： 从high向前查找小于data[0].key的记录，得到结果： 从low向后查找大于data[0].key的记录，得到结果： 第三次查找交换： 从high向前查找小于data[0]....
数据结构——排序（C语言）
qq_64592049的博客
10-04 920
时间复杂度：O（N^2）最差情况：逆序最优情况：顺序有序或者接近顺序有序。123456，每个数据都是直接插入到后面，一个都没挪。最优时间复杂度：O(N)
C语言实现八大排序算法合集
07-20
c语言
数据结构c语言版第八章排序分析.ppt
09-16
在C语言版本的数据结构课程中，第八章重点讲解了排序这一主题，这是处理数据时非常关键的操作，特别是在数据分析、数据库管理等领域。 排序是指将一组数据元素（如数字或记录）从任意顺序重新排列成按照特定关键字...
C语言编程八大排序汇总
05-07
这八大排序算法在实际编程中各有应用场景，如快速排序适合大型数据，归并排序适用于对稳定性有要求的场景，而基数排序则在处理整数排序时表现出色。理解并掌握这些排序算法有助于提升编程能力和解决复杂问题的能力。
数据结构_C语言_严蔚敏_排序
06-02
数据结构_C语言_严蔚敏 吴伟民版_排序 课程源程序
常见排序算法 数据结构 C语言实现
03-17
用C语言写的常见排序算法，包括直接选择排序、折半插入排序、起泡排序、快速排序、简单选择排序、归并排序等，已通过VC 6.0 测试。绝对实用。
c语言数据结构之排序
qq_55918164的博客
07-14 422
c语言数据结构之排序
数据结构：排序（C语言）
不再彷惶
12-25 325
#include<stdio.h> #define MAXSIZE 20 typedef struct{ int key; }redtype; typedef struct{ redtype r[MAXSIZE+1]; int length; }sqlist; //堆排序 void heapadjust(sqlist &L,int s, int m){ redtyp...
C语言 | 数据结构与算法 | 八大排序的讲解
凡事都是靠练习
05-08 1287
数据结构八大排序讲解：直接插入，希尔，选择，堆排序，冒泡，快排，归并，计数
数据结构——排序（C语言实现）
qq_63580639的博客
11-07 1118
主流的排序
数据结构：八大排序理解与C语言实现
W_J_F_的博客
01-18 1011
目录 序 插入排序 直接插入排序 希尔排序 选择排序 直接选择排序 堆排序 交换排序  冒泡排序 快速排序 归并排序 非比较算法 计数排序 时间复杂度 序 排序：就是将一组杂乱无章的数据按照一定的规律(升序或降序)组织起 来。  排序码：通常数据元素有多个属性域，其中有一个属性域可用来区分元 素，作为排序依据，该域即为排序码。   按照主排序码进行排序，排序的结果是...
【数据结构】排序-C语言版
局部变量和全局变量
03-25 1752
各类排序算法思想是什么？如何实现？时间复杂度分别是多少？稳定吗？ 常见的排序算法有如下7种： 插入排序 插入排序基本思想：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。 直接插入排序 当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与 array[i-1],array[i-2],…的排序码顺序进行比较，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值