经典排序(C语言)

最新推荐文章于 2024-10-10 06:15:00 发布
最新推荐文章于 2024-10-10 06:15:00 发布
阅读量51 收藏
点赞数 2
文章标签： c语言 排序算法 算法 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_77283790/article/details/134935055
版权

时间过得真快啊，转专业的第一个学期也已过去大半，学到了不少东西。但现在有种眼高手低的感觉，又有种无力感，要学的东西有很多，学校的课程不能落下，又怕基础不牢固

在这边立个flag吧，寒假学java，wxml，leetcode刷300题，暂且这样~

以下是正文

今天讨论几种经典排序😄 ,主要是书上的代码又臭又长😂 ，虽然说，有几个写的还是不错的😆~
下面的代码一部分来自b站up主 爱想代码的钟，还有一部分来自代码源的网课
时间复杂度

冒泡排序

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

//冒泡
void bubSort(int arr[], int length) {
	int flag = 1;//优化：若flag不为1；那么说明没有交换，数组有序
	while (length-- && flag) {
		flag = 0;
		for (int i = 0; i <  length; i++) {
			if (arr[i] > arr[i + 1]) {
				flag = 1;
				int tmp = arr[i];
				arr[i] = arr[i + 1];
				arr[i + 1] = tmp;
			}
		}
	}
}

选择排序

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

重复第二步，直到所有元素均排序完毕。

//选择
void sortArr(int arr[], int length) {
	for (int i=0;i<length;i++)
	{
		int min = i;
		for (int j = i+1; j < length; j++) {
			if (arr[i] > arr[j]) {
				min = j;
			}
		}
		int tmp = i;
		arr[i] = arr[min];
		arr[min] = arr[tmp];
	}
}

插入排序

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

//插入
void InsertArr(int arr[], int length) {
	for (int i = 1; i < length; i++) {
		for (int j = i; j > 0 && arr[j]<arr[j-1]; j--) {
			int tmp = arr[j];
			arr[j] = arr[j - 1];
			arr[j - 1] = tmp;
		}
	}
}

希尔排序

选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；

希尔排序是建立在插入排序的基础上进行优化的排序算法，所以希尔排序又叫做优化版的插入排序。

//希尔（优化版插入）在数据量大的时候速度更快

void shellArr(int arr[], int length) {
	int h = 4;
	int t = length / 3;
	/*while (h < t) {
		h = 3 * h + 1;
	}*/
	while (h>=1)
	{
		for (int i = h; i < length; i++) {
			for (int j = i; j > 0 && arr[j] < arr[j - h]; j-=h) {
				int tmp = arr[j];
				arr[j] = arr[j - h];
				arr[j - h] = tmp;
			}
		}
		h /= 2;//h/=3;
	}
}

快速排序

  • 从数列中挑出一个元素，称为 “基准”（pivot）;

  • 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

  • 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

void quicksort(int arr[],int left, int right)
{
	if (left >= right) {
		return;
	}
	int i = left;
	int j = right;
	int povit = arr[i];
	while (i<j)
	{
		while (i<j && arr[j]>=povit) {
			j--;
		}
		arr[i] = arr[j];
		while (i<j && arr[i]<=povit)
		{
			i++;
		}
		arr[j] = arr[i];
	}
	arr[i] = povit;
	if (left < i - 1) {
		quicksort(arr, left, i - 1);
	}
	if (i + 1 < right) {
		quicksort(arr, i + 1, right);
	}
}

void swap(int arr[], int i, int j) {
	int tmp = arr[i];
	arr[i] = arr[j];
	arr[j] = tmp;
}

void quicksort2(int arr[], int left, int right) {
	if (left >= right) {
		return;
	}
	int pivot = arr[left];
	int i = left + 1;
	int j = left + 1;
	while (j<=right) {
		if (arr[j] < pivot) {
			swap(arr, i, j);
			i++;
		}
		j++;
	}
	swap(arr, left, i - 1);
	quicksort2(arr, left, i - 2);
	quicksort2(arr, i, right);
}

归并排序

  • 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；

  • 设定两个指针，最初位置分别为两个已经排序序列的起始位置；

  • 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；

  • 重复步骤 3 直到某一指针达到序列尾；

  • 将另一序列剩下的所有元素直接复制到合并序列尾。

//归并排序，假设两个数组都有序
void mergesort(int a[], int alen,int b[], int blen, int* tmp) {
	int i = 0, j = 0, k = 0;
	while (i<alen && j<blen) 
		tmp[k++] = a[i] < b[j] ? a[i++] : b[j++];
		while (i<alen)
			tmp[k++] = a[i++];
		while (j < blen)
			tmp[k++] = b[j++];
}

//归并排序
void mergesort1(int arr[],int l, int r,int * c) {
	if (l == r) return;
	int m = (l + r) / 2;
	mergesort1(arr, l, m,c);
	mergesort1(arr, m + 1, r,c);
	int p1 = l, p2 = m + 1, tot = 0;
	while (p1<=m && p2<=r)
	{
		c[++tot] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
	}
		while (p1<=m)
		{
			c[++tot] = arr[p1++];
		}
		while (p2 <= r)
		{
			c[++tot] = arr[p2++];
		}
		for (int i = 1; i <= tot; i++) {
			arr[i + l - 1] = c[i];
		}
}

计数排序

初始化临时数组 tmp： tmp 数组用于统计每个元素的出现次数，初始化为全零。

复制原始数组 arr 到临时数组 brr： 这里创建了一个 brr 数组，用于保存原始数组的副本。

计数排序过程： 使用 tmp 数组统计每个元素的出现次数。

根据计数排序结果更新原始数组 arr： 通过循环遍历 tmp 数组，将元素按照计数结果还原到原始数组 arr。

实现排序的稳定性： 通过前缀和的方式，计算出每个元素在排序后数组中的位置，并存储在数组 r 中。

输出排序后的位置信息： 最后通过循环输出数组 r 中的元素，即表示每个元素在排序后数组中的位置。

//计数排序
int tmp[100] = { 0 };
void countsort(int arr[], int length) {
	int brr[Maxsize];
	for (int i = 0; i < length; i++) {
		brr[i] = arr[i];
	}

	for (int i = 0; i < length; i++) {
		tmp[arr[i]]++;
	}
	for (int i=0,j = 0; i < 100; i++) {
		for (int k = 0; k < tmp[i];k++) {
			arr[j++] = i;
		}
	}
	//原来的数组的数在现在数组的哪个位置，实现排序的稳定性
	// 排完后在第几位，相同数字，序号小的在前面
	//先做一个前缀和
	int c[1000] = { 0 };
	int r[1000];
	for (int i = 1; i < 100; i++) {
		tmp[i] += tmp[i - 1];
	}
	for (int i = length - 1; i >= 0; --i) {
		r[i] = tmp[brr[i]]--;
	}
	for (int i = 0; i < length; i++) {
		printf("%d ", r[i]);
	}
	printf("\n");
}

基数排序

假设现在我们已经排完了第i个及以后的关键字，现在要拍i-1个关键字，这里其实是一个双关键字排序（第一关键字是原来的第i-1个关键字，第二个关键字是原来的第i个及以后的关键字的rank）
我们只要把数字按第i个及以后的关键字从小到大的顺序放到数组里，在做一次计数排序就好了。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int n/*几个数字*/,m = 10/*数字最多几位*/,a[10001], s[10001]/*排完后在第几位，相同数字，序号小的在前面*/,v[10001]/*第一关键字*/, rank[10001]/*排完后在第几位，相同数字，序号小的在前面*/,c[10];//做计数排序的桶

void countingsort() {
	memset(c, 0, sizeof(c));
	for (int i = 1; i <= n; i++) {
		++c[v[i]];//c[当前关键字],将其放入桶中
	}
	for (int i = 1; i <= 9; i++) {//前缀和
		c[i] += c[i - 1];
	}
	for (int i = n; i >= 1; --i) {
		rank[s[i]] = c[v[s[i]]]--;//v[s[i]]表示当前关键字v的情况下，在s[i]这个位置。这句话表示，在s[i]这个位置在原数组中的位置是c[v[s[i]]]
	}
	for (int i = 1; i <= n; i++) {
		s[rank[i]] = i;//已知rank是已经排完的表示从v[0,10]，在原数组中的位置。s[rank[i]] 表示排序后数组中排名为 rank[i] 的位置上的元素。=i 表示将原始数组中的第 i 个元素放置到相应的位置上。这行代码的目的是将排完序的数组 s 的第 rank[i] 个位置上的值设置为 i。
	}
}

void radixsort() {
	for (int i = 0; i <= n; i++) {
		s[i] = i;//当前位置
	}
	int x = 1;//用来帮我们统计当前变量
	for (int i = 0; i <= m; i++, x *= 10) {//x*10表示1，10，100
		for (int j = 1; j <= n; j++) {
			v[j] = a[j] / x % 10;//当前关键字
		}
		countingsort();
	}for (int i = 1; i <= n; i++) {
		printf("%d ", a[s[i]]);
	}
	printf("\n");
}


int main()
{
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) {
		scanf("%d", &a[i]);
	}
	radixsort();
	
	return 0;
}

完整代码

#include<stdio.h>
#include<stdlib.h>
#include<time.h>


#define Maxsize 10

void initArr(int arr[], int length) {
	for (int i = 0; i < length; i++) {
		arr[i] = rand() % 100;
	}
}

void showArr(int arr[], int length) {
	for (int i = 0; i < length; i++) {
		printf("%d ", arr[i]);
	}
	printf("\n-----------------------\n");
}
//冒泡
void bubSort(int arr[], int length) {
	int flag = 1;//优化：若flag不为1；那么说明没有交换，数组有序
	while (length-- && flag) {
		flag = 0;
		for (int i = 0; i <  length; i++) {
			if (arr[i] > arr[i + 1]) {
				flag = 1;
				int tmp = arr[i];
				arr[i] = arr[i + 1];
				arr[i + 1] = tmp;
			}
		}
	}
}	
//选择
void sortArr(int arr[], int length) {
	for (int i=0;i<length;i++)
	{
		int min = i;
		for (int j = i+1; j < length; j++) {
			if (arr[i] > arr[j]) {
				min = j;
			}
		}
		int tmp = i;
		arr[i] = arr[min];
		arr[min] = arr[tmp];
	}
}
//插入
void InsertArr(int arr[], int length) {
	for (int i = 1; i < length; i++) {
		for (int j = i; j > 0 && arr[j]<arr[j-1]; j--) {
			int tmp = arr[j];
			arr[j] = arr[j - 1];
			arr[j - 1] = tmp;
		}
	}
}
//希尔（优化版插入）在数据量大的时候速度更快

void shellArr(int arr[], int length) {
	int h = 4;
	int t = length / 3;
	/*while (h < t) {
		h = 3 * h + 1;
	}*/
	while (h>=1)
	{
		for (int i = h; i < length; i++) {
			for (int j = i; j > 0 && arr[j] < arr[j - h]; j-=h) {
				int tmp = arr[j];
				arr[j] = arr[j - h];
				arr[j - h] = tmp;
			}
		}
		h /= 2;//h/=3;
	}
}

void quicksort(int arr[],int left, int right)
{
	if (left >= right) {
		return;
	}
	int i = left;
	int j = right;
	int povit = arr[i];
	while (i<j)
	{
		while (i<j && arr[j]>=povit) {
			j--;
		}
		arr[i] = arr[j];
		while (i<j && arr[i]<=povit)
		{
			i++;
		}
		arr[j] = arr[i];
	}
	arr[i] = povit;
	if (left < i - 1) {
		quicksort(arr, left, i - 1);
	}
	if (i + 1 < right) {
		quicksort(arr, i + 1, right);
	}
}

void swap(int arr[], int i, int j) {
	int tmp = arr[i];
	arr[i] = arr[j];
	arr[j] = tmp;
}

void quicksort2(int arr[], int left, int right) {
	if (left >= right) {
		return;
	}
	int pivot = arr[left];
	int i = left + 1;
	int j = left + 1;
	while (j<=right) {
		if (arr[j] < pivot) {
			swap(arr, i, j);
			i++;
		}
		j++;
	}
	swap(arr, left, i - 1);
	quicksort2(arr, left, i - 2);
	quicksort2(arr, i, right);
}

//归并排序，假设两个数组都有序
void mergesort(int a[], int alen,int b[], int blen, int* tmp) {
	int i = 0, j = 0, k = 0;
	while (i<alen && j<blen) 
		tmp[k++] = a[i] < b[j] ? a[i++] : b[j++];
		while (i<alen)
			tmp[k++] = a[i++];
		while (j < blen)
			tmp[k++] = b[j++];
}

//归并排序
void mergesort1(int arr[],int l, int r,int * c) {
	if (l == r) return;
	int m = (l + r) / 2;
	mergesort1(arr, l, m,c);
	mergesort1(arr, m + 1, r,c);
	int p1 = l, p2 = m + 1, tot = 0;
	while (p1<=m && p2<=r)
	{
		c[++tot] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
	}
		while (p1<=m)
		{
			c[++tot] = arr[p1++];
		}
		while (p2 <= r)
		{
			c[++tot] = arr[p2++];
		}
		for (int i = 1; i <= tot; i++) {
			arr[i + l - 1] = c[i];
		}
}


//计数排序
int tmp[100] = { 0 };
void countsort(int arr[], int length) {
	int brr[Maxsize];
	for (int i = 0; i < length; i++) {
		brr[i] = arr[i];
	}

	for (int i = 0; i < length; i++) {
		tmp[arr[i]]++;
	}
	for (int i=0,j = 0; i < 100; i++) {
		for (int k = 0; k < tmp[i];k++) {
			arr[j++] = i;
		}
	}
	//原来的数组的数在现在数组的哪个位置，实现排序的稳定性
	// 排完后在第几位，相同数字，序号小的在前面
	//先做一个前缀和
	int c[1000] = { 0 };
	int r[1000];
	for (int i = 1; i < 100; i++) {
		tmp[i] += tmp[i - 1];
	}
	for (int i = length - 1; i >= 0; --i) {
		r[i] = tmp[brr[i]]--;
	}
	for (int i = 0; i < length; i++) {
		printf("%d ", r[i]);
	}
	printf("\n");
}



int main() 
{	
	srand((unsigned int)time(NULL));
	int arr[Maxsize];
	int c[2000];
	/*initArr(arr, Maxsize);
	showArr(arr, Maxsize);
	bubSort(arr, Maxsize);
	showArr(arr, Maxsize);
	sortArr(arr, Maxsize);
	showArr(arr, Maxsize);
	InsertArr(arr, Maxsize);
	showArr(arr, Maxsize);
	shellArr(arr, Maxsize);
	quicksort2(arr, 0, Maxsize - 1);
	showArr(arr, Maxsize);*/
	initArr(arr, Maxsize);
	showArr(arr, Maxsize);
	/*mergesort1(arr, 0, Maxsize - 1, c);*/
	countsort(arr, 10);
	showArr(arr, Maxsize);

	//归并排序使用该数组
	/*int a[5] = { 1,3,5,7,9 };
	int b[5] = { 0,2,4,6,8 };
	int tmp[10];
	mergesort(a, 5, b, 5, tmp);
	showArr(tmp, 10);*/
	return 0;
}
豆酥糖
关注
C语言—冒泡排序
xianming_flag的博客
11-30 23万+
C语言排序算法-冒泡排序 从键盘输入的10个整数按从小到大的顺序排序后输出 #include<stdio.h> void main() { int n[10] = { 25,35,68,79,21,13,98,7,16,62 };//定义一个大小为10的数组 int i, j, temp; for (i = 1; i <= 9; i++)//外层循环是比较的轮数，数组内有10个数，那么就应该比较10-1=9轮 { for (j = 0; j <= 9 - i; j++)
【排序算法】希尔排序（C语言）
weixin_52811588的博客
08-21 5万+
希尔排序也叫缩小增量排序，这里详述了希尔排序的步骤和过程，并用C语言实现了希尔排序，提供给大家参考
C语言——冒泡排序
热门推荐
记录学习点滴
03-13 44万+
冒泡排序的原理是：从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。 以从小到大排序为例，第一轮比较后，所有数中最大的那个数就会浮到最右边；第二轮比较后，所有数中第二大的那个数就会浮到倒数第二个位置……就这样一轮一轮地比较，最后实现从小到大排序。 代码如下 #include<stdio.h> void BBsort(int arr[], int size) { int j,i,tem; for (i = 0; i ..
C语言冒泡排序
小S的博客
04-29 8万+
冒泡排序？不难，这篇就够了！ for(int i=0;i
归并排序 c语言详解
jxtjiayou的博客
10-18 1032
归并排序
C语言实现冒泡排序
wantsnowfly的博客
01-15 9万+
冒泡排序作为学习排序最基本的算法，具有稳定性与实用性。 下面是C语言冒泡排序的源代码 #include<stdio.h> int main(void) { int a[10]={6,4,3,2,7,8,9,10,1,5}; int i,k,w; for(i=0;i<9;i++) { for(k=0;k<9-i;k++) { if(a[k]>a[k+1]) { ...
c语言-快速排序
安权_code的博客
12-01 8714
快速排序作为多种排序方法中效率最高的一种，其底层原理被广泛运用，他的核心思想与二叉树结构中的递归逻辑相似，首先标记一个元素作为基准点，然后利用该基准点把数组分成左右两个区间，并且使小于该基准点的元素放在左区间，大于该基准点的元素放在右区间，如此反复递归，直到数组为一个有序数组。
【排序算法】选择排序（C语言）
weixin_52811588的博客
08-23 8万+
选择排序是最简单的算法之一，这里使用C语言实现了选择排序，并且完成了选择排序的优化实现，欢迎大家参考
C语言的5种简单排序算法
Finecsr的博客
04-27 6万+
基本概要： 本文主要介绍五种简单常用的排序算法：冒泡排序，快速排序，插入排序，选择排序，希尔排序，包括它们的基本思想和代码实现。值得一说的是：插入排序，冒泡排序，选择排序平均情况下的时间复杂度为，因此在排序数据较少的情况下较好；而希尔排序和快速排序的平均时间复杂度为，因此在排序数据较多的情况下较好，但是对于快速排序而言，数据基本有序时反而不好，接下来会详细阐述。 1.冒泡排序（Bubble Sort） 基本思想： 冒泡排序是一个非常好理解的排序，顾名思义——冒泡，此时将要排序的数据从上至下排列，从最
C语言插入排序
hanwangyyds的博客
09-05 2153
本文主要讲解插入排序中的直接插入排序和希尔排序。
经典排序 C语言实现
07-12
重温经典排序思想，并用C语言指针实现排序算法
049 基数排序 C语言 基数排序 C语言
06-01
在C语言中实现基数排序，需要理解C语言的基本语法和数组操作。 基数排序的核心思想是将待排序的数组按照每一位进行排序，从最低有效位（Least Significant Digit, LSD）开始，逐步到最高有效位（Most Significant ...
冒泡排序和简单选择排序c语言
03-14
冒泡排序 简单选择排序 c语言基础 排序算法 数组操作 排序算法实验 简单的c语言程序 排序算法输出
经典排序算法（C语言实现）.zip
10-10
本项目“经典排序算法（C语言实现）”提供了C语言版本的多种常见排序算法实现，对于学习和理解排序算法有极大的帮助。下面我们将深入探讨这些排序算法的核心原理及其C语言实现。 1. 冒泡排序（Bubble Sort） 冒泡...
C语言基本概念
ROBIN__dyc的博客
10-03 784
标识符：编写程序时，需要对变量、函数、宏和其他实体进行命名，这些名字称为标识符。函数是C语言中构建程序的构建块，事实上，C语言是函数的集合。函数分为两大类，一类是程序员编写的函数，一类是作为C语言实现的一部分提供的函数，即库函数。所有指令都是以字符#开始的，默认只占一行，每条指令的结尾没有分号或其他特殊标记。int 型变量取值的范围是有限的，通常为-2³¹～2³¹-1，但某些计算机上最大整数可能只有32767。语句是程序运行时执行的命令，C语言规定每条语句都要以分号结尾（复合语句是例外）。
C 共用体
最新发布
lly202406的博客
10-10 338
在C语言中，共用体使用union关键字定义。共用体的所有成员共享同一块内存空间，这意味着在任何时刻，共用体只能存储其中一个成员的数据。// ...其中，union_name是共用体的名称，type是成员的数据类型，member1member2等是共用体的成员。
排序--DS
2302_79249715的博客
10-08 794
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。： 假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 442
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 1291
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
C语言实现经典排序算法全集
"这篇文章主要介绍了C语言中的八种经典排序算法，包括希尔排序、二分插入法、直接插入法、带哨兵的直接排序法、冒泡排序、选择排序、快速排序以及堆排序。每种排序算法都有相应的源代码示例，方便读者理解和实践。" ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值