各类排序算法

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

目录

1.选择排序

2.冒泡排序

3.插入排序

4.归并排序

5.堆排序

6.快速排序

7.桶排序：

               1.计数排序

               2.基数排序

总结：

1.选择排序

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

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

int main()
{
	int n = 0;
	scanf("%d", &n);
	int* arr = (int*)malloc(4 * n);
	for (int i = 0; i < n; i++) {
		scanf("%d", arr + i);
	}

	int cur = 0;
	for (int i = 0; i < n-1; i++) {
		cur = i;
		for (int j = i + 1; j < n; j++) {
			if (arr[j] < arr[cur]) {
				cur = j;
			}
		}
		if (cur != i) {
			swap(arr, i, cur);
		}
	}

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

	return 0;

}

2.冒泡排序

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

void swap(int* arr, int x, int y) {
	int tmp = arr[x];
	arr[x] = arr[y];
	arr[y] = tmp;
}

void BubbleSort(int* arr, int L, int R) {
	if (arr == NULL || R - L - 1 < 2) {
		return;
	}

	for (int i = R; i > L; i--) {
		for (int j = L; j < i; j++) {
			if (arr[j] > arr[j + 1]) {
				swap(arr, j, j + 1);
			}
		}
	}
}

int main()
{
	int n = 0;
	scanf("%d", &n);
	int* arr = (int*)malloc(sizeof(int)*n);
	for (int i = 0; i < n; i++) {
		scanf("%d", arr + i);
	}

	BubbleSort(arr, 0, n - 1);

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

	return 0;
}

3.插入排序

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

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

int main()
{
	int n = 0;
	scanf("%d", &n);
	int* arr = (int*)malloc(n * 4);
	for (int i = 0; i < n; i++) {
		scanf("%d", arr + i);
	}

	for (int i = 1; i < n; i++) {
		for (int j = i; j > 0; j--) {
			if (arr[j] < arr[j - 1]) {
				swap(arr, j, j - 1);
			}
			else {
				break;
			}
		}
	}

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

	return 0;
}

4.归并排序

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

void Merage(int* arr, int L, int M, int R) {
	
	int* help = (int*)malloc(sizeof(int)*(R - L + 1));
	int p1 = L, p2 = M + 1;
	int i = 0;
	while (p1 <= M && p2 <= R) {
		help[i++] = (arr[p1] > arr[p2] ? arr[p2++] : arr[p1++]);
	}

	while (p1 <= M) {
		help[i++] = arr[p1++];
	}

	while (p2 <= R) {
		help[i++] = arr[p2++];
	}

	for (int j = 0; j <= R - L; j++) {
		arr[L + j] = help[j];
	}
	free(help);
	help = NULL;
}

void Merage_Sort(int* arr, int L, int R) {
	if (L == R) {
		return;
	}

	int mid = (L + ((R - L) >> 1));
	Merage_Sort(arr, L, mid);
	Merage_Sort(arr, mid + 1, R);

	Merage(arr, L, mid, R);
}

int main()
{
	int n = 0;
	scanf("%d", &n);
	int* arr = (int*)malloc(sizeof(int)*n);
	for (int i = 0; i < n; i++) {
		scanf("%d", arr + i);
	}

	Merage_Sort(arr, 0, n - 1);

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


	return 0;
}

5.堆排序

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

int size = 0;

void swap(int* arr,int x,int y){
	if (arr == NULL) {
		return;
	}

	int tmp = arr[x];
	arr[x] = arr[y];
	arr[y] = tmp;
}

void heepdive(int* arr, int width) {
	if (arr == NULL){
		return;
	}
	int index = width;
	while (arr[index] > arr[(index - 1) / 2]) {
		swap(arr, index, (index - 1) / 2);
		index = (index - 1) / 2;
	}
}

void HeepIfy(int* arr) {
	if (arr == NULL) {
		return;
	}
	int index = 0, largest = 0;
	int leaf = 2 * index + 1;
	while (leaf < size) {
		largest = (leaf + 1 < size) && (arr[leaf] < arr[leaf + 1]) ? leaf + 1 : leaf;
		largest = arr[index] < arr[largest] ? largest : index;
		if (largest == index) {
			break;
		}
		swap(arr, index, largest);
		index = largest;
		leaf = index * 2 + 1;
	}
}

void HeepSort(int* arr, int L, int R) {
	
	for (int i = 0; i < (R - L + 1); i++) {
		swap(arr, L, size - 1);
		size--;
		HeepIfy(arr);
	}
}

int main()
{
	int n = 0;
	scanf("%d", &n);
	int* arr = (int*)malloc(sizeof(int)*n);
	for (int i = 0; i < n; i++) {
		scanf("%d", arr + size);
		size++;
		heepdive(arr, size - 1);
	}
	
	 HeepSort(arr, 0, n - 1);

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

	return 0;
}

6.快速排序

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

int random(int a, int b) {
	return (rand() % b + a);
}

void swap(int* arr, int x, int y) {
	int tmp = arr[x];
	arr[x] = arr[y];
	arr[y] = tmp;
}

int* sort(int* arr, int L, int R) {
	int small = L - 1;
	int more = R;
	int cur = L;
	while (cur < more) {
		if (arr[cur] < arr[R]) {
			swap(arr, cur++, ++small);
		}
		else if (arr[cur] > arr[R]) {
			swap(arr, cur, --more);
		}
		else {
			cur++;
		}
	}
	swap(arr, more, R);
	int* help = (int*)malloc(4 * 2);
	help[0] = small + 1;
	help[1] = more;
	return help;
}

void QuickSort(int* arr, int L, int R) {
	if (arr == NULL || R - L + 1 < 2) {
		return;
	}

	if (L >= R) {
		return;
	}

	swap(arr, random(L, R), R);

	int* p = sort(arr, L, R);
	QuickSort(arr, L, *p - 1);
	QuickSort(arr, *(p + 1) + 1, R);
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	int* arr = (int*)malloc(sizeof(int)*n);
	for (int i = 0; i < n; i++) {
		scanf("%d", arr + i);
	}

	QuickSort(arr, 0, n - 1);

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

	return 0;
}

7.桶排序：

               1.计数排序

               2.基数排序

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

int getDigit(int num, int i) {
	int res = 0;
	i -= 1;
	while (i--) {
		res = num / 10;
	}

	return num % 10;
}

void RadixSort(int* arr, int L, int R, int digit) {
	if (arr == NULL || R - L + 1 < 2) {
		return;
	}

	int* help = (int*)malloc(sizeof(int)*(R - L + 1));
	int* count = (int*)malloc(sizeof(int) * 10);
	
	for (int i = 1; i <= digit; i++) {
		for (int c = 0; c < 10; c++) {
			count[c] = 0;
		}

		for(int j = L; j <= R; j++) {
			count[getDigit(arr[j], i)]++;
		}

		for (int p = 1; p < 10; p++) {
			count[p] += count[p - 1];
		}

		for (int q = R; q >=L; q--) {
			help[--count[getDigit(arr[q], i)]] = arr[q];
		}

		for (int z = L; z <= R; z++) {
			arr[z] = help[z-L];
		}
	}
}

int maxbits(int* arr, int n) {
	if (arr == NULL) {
		return 0;
	}
	int max = arr[0], i = 0, res = 0;
	for (i = 0; i < n; i++) {
		max = max < arr[i] ? arr[i] : max;
	}

	while (max > 0) {
		res++;
		max /= 10;
	}

	return res;
}

int main()
{
	int n = 0;
	scanf("%d", &n);
	int* arr = (int*)malloc(sizeof(int)*n);
	for (int i = 0; i < n; i++) {
		scanf("%d", arr + i);
	}

	RadixSort(arr, 0, n - 1, maxbits(arr, n));

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

	return 0;
}

总结：

1.不具备稳定性的排序：选择排序，快速排序，堆排序；

   具备稳定性的排序：冒泡排序，插入排序，归并排序，一切桶排序思想下的排序。

目前没有找到时间复杂度为O(n*log(n))，额外空间复杂度为O(1)，又稳定的排序。

2.

时间复杂度空间复杂度是否具有稳定性
选择排序O(n^2)O(1)无
冒泡排序O(n^2)O(1)有
插入排序O(n^2)O(1)有
归并排序O(n*log(n))O(n)有
快速排序O(n*log(n))O(log(n))无
堆排序O(n*log(n))O(1)无

3.工程上对算法的改进：1.充分利用O(n^2)和O(n*log(n))各自的优势;2.稳定性的考虑。

啼莺修竹
关注
排序
Zhxin606a的博客
03-07 319
转自https://www.cnblogs.com/onepixel/articles/7674659.html 0、算法概述 0.1 算法分类 十种常见排序算法可以分为两大类： 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时...
排序算法笔记详解（上）
pshdhx的博客
02-16 334
排序算法详解-来自左程云笔记总结
java-冒泡和选择排序，比较记忆
缕缕清风戏豪客的博客
08-04 382
冒泡和选择排序是java中基本而且重要的排序方式，一些初学者往往会被二者的逻辑给饶的晕头转向，所以下面给出两段代码，来比较记忆，这样会更容易理解记忆： public static void maoP(int []arr){         for(int i=0;i&lt;arr.length-1;i++){//无论是选择还是冒泡，控制循环次数的i值都是小于arr.length-1(即比较的次数...
基于Java实现冒泡排序
Lawliet_233的博客
03-13 156
冒泡排序 public static void bubbleSort(int[] arr) { if(arr == null || arr.length&lt;2) return ; for(int e = arr.length-1; e &gt; 0; e--){ for(int i = 0; i &lt; e...
【记录】算法 - JavaScript版
Youkirrr_的博客
03-11 627
0、基础 （1）异或 相异为1，相同为0。 性质 N^0=N N^N=0 满足交换律和结合律 （2）与 1&1=1，其他都=0。 //利用临时变量实现交换 function swap(arr, i, j){ let temp = arr[i]; arr[i] = arr[j]; arr[j] = arr[i]; } //利用异或实现交换 //前提：i和j地址值不同（相当于自己地址值里的内容跟自己地址值里的内容异或=0）。 function swap(arr, i, j){ arr
C语言各类排序算法代码程序以及说明文档
05-12
本资料包“C语言各类排序算法代码程序以及说明文档”提供了多种经典的排序算法实现，这对于学习C语言，特别是进行课程设计或期末作业来说，是非常有价值的资源。 首先，我们来看几种常见的排序算法： 1. **冒泡...
各类排序算法实现程序，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序
03-06
该程序实现了多种排序算法，并提供了选项菜单供用户选择排序算法。除了排序算法外，还包括了查找最大最小值、计算平均值和总和的功能。 主函数 main：包含一个主程序循环，通过菜单选择排序算法或其他功能。 菜单...
各类排序算法分析比较特点复杂度分析
03-24
### 各类排序算法分析比较特点复杂度分析 #### 排序类别 排序算法可以根据不同的标准进行分类。根据数据结构可以分为基于数组的排序和基于链表的排序；按照是否利用额外存储空间可分为原地排序和非原地排序；根据...
各类排序算法java的实现.pdf
07-14
在IT领域，排序算法是计算机科学中的基础概念，特别是在数据处理和算法分析方面。Java作为广泛应用的编程语言，实现各种排序算法是程序员必备的技能。本文将深入探讨四种经典的排序算法：插入排序、冒泡排序、选择...
排序算法总结
Cara_XJ的博客
02-15 363
1、冒泡排序 两个相邻的数比较大小，较大的数下沉，较小的数冒起来。 public static void BubbleSort(int [] arr){ int temp;//临时变量 for(int i=0; i<arr.length-1; i++){ //表示趟数，一共arr.length-1次。 for(int j=arr.lengt...
几种实现i和j位置上的元素交换的方法(包含使用临时变量，逻辑运算符，算数运算等方法)及其性能分析
yxg520s的博客
01-18 677
https://www.cnblogs.com/ider/archive/2012/05/03/xor_swap_issues.html 基础知识：各种运算符号 算数运算符(9个)：+ - * / % ++ – 关系运算符(6个)：== != > >= < <= 逻辑运算符(6个)： &&（逻辑与）、||（逻辑或）、！（逻辑非），还有几个容易弄混淆的位操作符（进行按位操作）：&（按位与）、|（按位或）、~（按位非），后面三个既
算法体系版-左程云-笔记（1）
最新发布
VAN
04-06 113
算法学习（1）
java常用算法总结
hypmxy的博客
09-19 521
冒泡算法 1、首先我们将交换方法提取出来 public static void swap(int[] arr,int i,int j){       //交换算法有两种种写法，分别如下       //1普通写法       int temp = arr[i];        arr[j] = arr[i];        arr[j] = temp;       //2通过异或...
数据在内存中的存储(2)
qq_66581313的博客
05-27 178
第一题 int main() { unsigned int i = 0; for (i = 9; i >= 0; i--) { printf("%u\n", i); } return 0; } 这个代码输入的结果是什么？ 首先
选择排序中用异或实现swap（）时出现的问题
激进的蜗牛
03-06 426
具体写了几个简单的排序，其中swap函数使用了异或的方法实现： /** * 交换数组中的两个数,一个数自己与自己异或结果为0；一个数与0异或，结果还是自己。 * * @param arr * @param i * @param j */ public static void swap(int[] arr, int i, int j) { arr[i] = arr[i] ^ a...
在不引入第三个中间变量的情况下，完成两个数字的交换
weixin_47335679的博客
09-21 341
在进行数组排序时，我们经常会自定义一个swap()函数，例如： int temp = arr[i]; arr[i] = arr[j]; arr[j] = arr[i]; 那么如何在不引入中间变量的情况下，完成两个数字的交换呢？ 方法一：先加后减法 arr[i] = arr[i] + arr[j]; arr[j] = arr[i] - arr[j]; arr[i] = arr[i] - arr[j]; 说明：先将arr[i]和arr[j]两数求和，求和之后减去其中某一个数，就得到了另一个数的值。
【malloc函数 创建动态数组】
m0_熊猫馆主的博客
05-14 7829
malloc 向系统申请分配指定内存空间：size个字节。返回类型是 未指定类型的指针 ：void* 类型。
int *a = (int*)malloc(n*sizeof(int))；意思
qq_46987086的博客
12-09 3092
在内存中开辟一个大小为N个INT大小的空间出来以备存储比如说n=5这个INT占两个字节吧，就是开出个10个字节的内存空间并把JS指向这个空间(不过有的INT是点占四个字节) 分配n个int空间给js js=malloc(n*sizeof(int))的意思是在内存中开辟一个长度等于(int)的空间,并用指针js指向该地址. ——————————————————————— ...
C++模板实现各类排序算法
"这篇资源提供的是C++实现的各种排序算法的模板类，包括快速排序、选择排序、冒泡排序、插入排序、堆排序以及二叉排序树排序。这些算法是编程基础中的重要部分，适用于数据处理和优化。作者提供了完整的代码实现，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值