冒泡排序推导及模拟实现和排序库函数

最新推荐文章于 2024-10-11 16:56:17 发布
最新推荐文章于 2024-10-11 16:56:17 发布
阅读量68 收藏
点赞数 1
文章标签： 算法 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80097977/article/details/140874339
版权 
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

//void menu()
//{
//	printf("#######################\n");
//	printf("#### 1. Add  2. Sub####\n");
//	printf("#### 3. Mul  5. Div####\n");
//	printf("####    0. exit    ####\n");
//	printf("#######################\n");
//
//}
//int Add(int a, int b)
//{
//	return a + b;
//}
//int Sub(int a, int b)
//{
//	return a - b;
//}
//int Mul(int a, int b)
//{
//	return a * b;
//}
//int Div(int a, int b)
//{
//	return a / b;
//}
//
//int calc(int(*pf)(int, int))
//{
//	int x = 0;
//	int y = 0;
//	int ret = 0;
//	printf("请选择两个数：");
//	scanf("%d %d", &x, &y);
//	ret = (*pf)(x, y);
//	printf("%d\n", ret);
//}
//int main()
//{
//	int input = 0;
//	do {
//		menu();
//		printf("请选择：");
//		scanf("%d", &input);
//		switch (input)
//		{
//		case 1:
//			calc(Add);
//			break;
//		case 2:
//			calc(Sub);
//			break; 
//		case 3:
//			calc(Mul);
//			break;
//		case 4:
//			calc(Div);
//			break;
//		case 0:
//			printf("推出计算器\n");
//			break;
//		default:
//			printf("选择错误，请重新选择");
//			break;
//		}
//		
//
//	} while (input);
//	return 0;
//}


//void menu()
//{
//	printf("#######################\n");
//	printf("#### 1. Add  2. Sub####\n");
//	printf("#### 3. Mul  5. Div####\n");
//	printf("####    0. exit    ####\n");
//	printf("#######################\n");
//
//}
//int Add(int a, int b)
//{
//	return a + b;
//}
//int Sub(int a, int b)
//{
//	return a - b;
//}
//int Mul(int a, int b)
//{
//	return a * b;
//}
//int Div(int a, int b)
//{
//	return a / b;
//}
//
//int main()
//{
//	int input = 0;
//	int x = 0;
//	int y = 0;
//	int ret = 0;
//	int(*pfarr[])(int, int) = { 0,Add,Sub,Mul,Div };
//	do {
//		menu();
//		printf("请选择：");
//		scanf("%d", &input);
//		if (input == 0)
//		{
//			printf("推出计算器\n");
//		}
//		else if (input >= 1 && input <= 4)
//		{
//			printf("请选择两个数：");
//			scanf("%d %d", &x, &y);
//			ret = pfarr[input](x, y);
//			printf("%d\n", ret);
//		}
//		else
//		{
//			printf("选择错误，请重新选择。");
//		}
//
//	} while (input);
//	return 0;
//}

//指向函数指针数组的指针
//指向函数指针数组的指针是一个指针
//指针指向一个数组，数组的元素都是函数指针;

//int main()
//{
//	//函数指针数组
//	int(*pfarr[])(int, int) = { 0,Add,Sub,Mul,Div };
//
//	//指向[函数指针数组]的指针
//	int (*(*ppfarr)[5])(int, int) = &pfarr;
//	return 0;
//}

//回调函数
//回调函数就是一个通过函数指针调用的函数。
//如果把函数的指针(地址)作为参数传递给另一个函数，
//当这个指针被用来调用其所指向的函数时,成为回调函数
//回调函数不是由该函数的实现方直接调用，
//而是在特定的事件或条件发生时由另外一方调用的，
//用于对该事件或条件进行响应。


//冒泡排序
//void bubble_sort(int* arr, int sz)
//{
//	int i = 0;
//	for (i = 0; i < sz - 1; i++)
//	{
//		int j = 0;
//		for (j = 0; j < sz - 1 - i; j++)
//		{
//			if (arr[j] > arr[j + 1])
//			{
//				int tmp = arr[j];
//				arr[j] = arr[j + 1];
//				arr[j + 1] = tmp ;
//				
//			}
//		}
//	}
// }
//int main()
//{
//	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	bubble_sort(arr, sz);
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}

//优化
void bubble_sort(int* arr, int sz)
{
	int i = 0;//趟数
	for (i = 0; i < sz - 1; i++)
	{
		int flag = 1;//假设数组是已经排好序的
		//一趟冒泡排序的过程
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
				flag = 0;
			}
		}
		if (flag == 1)
		{
			break;
		}
	}
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}



//void bubble_sort(int* arr, int sz)
//{
//	int i = 0;
//	for (i = 0; i < sz - 1; i++)
//	{
//		int flag = 1;
//		int j = 0;
//		for (j = 0; j < sz - 1 - i; j++)
//		{
//			if (arr[j] > arr[j + 1])
//			{
//				int tmp = arr[j];
//				arr[j] = arr[j + 1];
//				arr[j + 1] = tmp;
//				flag = 0;
//			}
//		}
//		if (flag == 1)
//		{
//			break;
//		}
//	}
//}
//int main()
//{
//	int arr[] = { 0,1,2,3,4,5,6,8,9 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	bubble_sort(arr, sz);
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}




//qsort -> 适用于任何数据(整型，结构体，字符……)
//使用快速排序的思想实现的一个排序函数
#include<stdlib.h>
//void qsort(void* base, //要排序的数据的起始位置
//	       size_t num, //待排序的数据元素的个数
//	       size_t width,//待排序的数据元素的大小(单位是字节)
//	       int(*cmp)(const void* e1, const void* e2)//函数指针-比较函数
//	      //cmp -> 比较函数的地址
//	      //e1，e2 -> 要比较的两个元素的地址
//           );

//比较2个整型元素
//e1指向一个整数
//e2指向另一个整数
//int cmp_int(const void* e1, const void* e2)
//{
//	if (*e1 > *e2)
//	{
//		return 1;
//	}
//	else if (*e1 == *e2)
//	{
//		return 0;
//	}
//	else
//	{
//		return -1;
//	}
//	//但是 void*类型的指针不能解引用
//}
int cmp_int(const void* e1, const void* e2)
{
	//默认为升序
	return (*(int*)e1 - *(int*)e2);//强制类型转换为整型
	//默认为降序
	//return (*(int*)e2 - *(int*)e1);
}
int main()
{
	//把数组排成升序(默认为升序)
	int arr[] = { 0,1,2,3,4,5,6,8,9 };
	//int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

//int main()
//{
//	int a = 10;
//	char* pa = &a;
//	void* pv = &a;
//	//void* 是无具体类型的指针，可以接受任何类型的地址
//	//void* 是无具体类型的指针，所以不能解引用操作，也不能++整数
//	return 0;
//}


#include<stdio.h>
#include<stdlib.h>
//int cmp_int(const void* e1, const void* e2)
//{
//	return (*(int*)e1 < *(int*)e2);
//}
//int main()
//{
//	int arr[] = { 9,8,7,6,5,4,3,2,1 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	qsort(arr, sz, sizeof(arr[0]), cmp_int);
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}

//测试使用qsort来排序结构数据
//#include<string.h>
//struct Stu
//{
//	char name[24];
//	int age;
//};
//int cmp_stu_by_name(const void* e1, const void* e2)
//{
//	//strcmp -->  >0;==0;<0;
//	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
//}
//void test()
//{
//	struct Stu s[] = { {"李客川",22},
//	                   {"胡春艳",23} };
//	int sz = sizeof(s) / sizeof(s[0]);
//	qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
//	printf("%s %d\n", s->name, s->age);
//}
//int main()
//{
//	test();
//
//	return 0;
//}

//#include<string.h>
//struct Stu
//{
//	char name[24];
//	int age;
//};
//int cmp_stu_by_age(const void* e1, const void* e2)
//{
//	//strcmp -->  >0;==0;<0;
//	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
//}
//void test()
//{
//	struct Stu s[] = { {"李客川",22},
//					   {"胡春艳",23} };
//	int sz = sizeof(s) / sizeof(s[0]);
//	qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
//	printf("%s %d\n", s->name, s->age);
//}
//int main()
//{
//	test();
//
//	return 0;
//}

//改造冒泡排序
void Swap(char* buf1, char* buf2, int width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

int cmp_int(const void* e1, const void* e2)
{

	return (*(int*)e1 - *(int*)e2);
}
void bubble_sort(void*base,int sz,int width,int(*cmp)(const void*e1,const void*e2))
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int flag = 1;
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0) 
			{
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
				flag = 0;
			}
		}
		if (flag == 1)
		{
			break;
		}
	}
}

void test3()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	test3();
	return 0;
}

2301_80097977
关注
javascript 冒泡排序 正序和倒序实现代码
10-28
在JavaScript中，冒泡排序可以实现升序（正序）和降序（倒序）两种排序方式。 首先，我们来看一下冒泡排序实现升序排序的原理。在升序排序中，我们需要比较数组中的相邻元素，如果当前元素比下一个元素小，那么就...
matlab进行数组排序,不用matlab库函数实现数据排序
11-23
matlab数组排序,不用matlab库函数实现数据排序
冒泡排序——C++代码
06-08
冒泡排序是一种基础的排序算法，它通过重复遍历待排序的序列，比较相邻元素并交换位置...在实际开发中，可能会选择更高效的排序算法，如快速排序、归并排序等，但在学习阶段，掌握冒泡排序的实现和优化是非常有价值的。
S7-200SMART冒泡排序源程序及库文件（可重复调用）.rar
10-13
在S7-200SMART中，库文件可能包含冒泡排序算法的实现，程序员可以通过调用这些库函数，无需关心排序算法的底层细节，从而更快地开发应用程序。库文件的使用降低了开发难度，减少了错误，同时也方便了代码维护。 综...
冒泡排序的c++代码实现
05-11
通过深入理解这些知识点，不仅可以掌握冒泡排序的C++实现，还能进一步提升在算法设计和程序编写方面的技能。在实际应用中，虽然冒泡排序效率较低，但它有助于理解和学习基础的排序原理，对于初学者来说是非常有价值...
二叉树系列 10/11
2301_78191305的博客
10-11 245
在这些路径中，只有红色和绿色的路径是伪回文路径，因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ，绿色路径 [2,1,1] 存在回文排列 [1,2,1]。总共有 3 条从根到叶子的路径：红色路径 [2,3,3] ，绿色路径 [2,1,1] 和路径 [2,3,1]。（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）（一个节点的祖父节点是指该节点的父节点的父节点。」的，当它满足：路径经过的所有节点值的排列中，存在一个回文序列。
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 442
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 1291
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
c语言练习题2(字符串和函数的使用)
m0_74859128的博客
10-10 211
回文函数用于判断一个给定的字符串是否为回文。输入是一个字符数组（字符串），输出是一个布尔值，表示该字符串是否为回文。编写一个 C 语言程序，计算两个整数在二进制表示中有多少位不同。2. 比较这两个整数在二进制表示中的每一位（共32位）是否不同。1. 提示用户输入两个整数。3. 统计不同的位的数量。4. 输出不同的位数。
【三】【算法】P1007 独木桥,P1012 [NOIP1998 提高组] 拼数,P1019 [NOIP2000 提高组] 单词接龙
最新发布
m0_74163972的博客
10-11 393
你希望找些刺激，于是命令你的士兵们到前方的一座独木桥上欣赏风景，而你留在桥下欣赏士兵们。另外，总部也在安排阻拦敌人的进攻，因此你还需要知道你的部队最多需要多少时间才能全部撤离独木桥。单词接龙是一个与我们经常玩的成语接龙相类似的游戏，现在我们已知一组单词，且给定一个开头的字母，要求出以这个字母开头的最长的“龙”（每个单词都最多在“龙”中出现两次），在两个单词相连时，其重合部分合为一部分，例如。突然，你收到从指挥部发来的信息，敌军的轰炸机正朝着你所在的独木桥飞来！的数据，满足初始时，没有两个士兵同在一个坐标，
设计算法int IsExistEL(MGraph G)，判断G是否存在EL路径，若存在，则返回1 ，否则返回0。
m0_56332819的博客
10-11 61
设计算法int IsExistEL(MGraph G)，判断G是否存在EL路径，若存在，则返回1 ，否则返回0。C语言
【算法】---归并排序（递归非递归实现）
何春秋的博客
10-03 1191
归并排序 in Java
算法讲解—最小生成树（Kruskal 算法）
ZH_qaq的博客
10-05 1353
根据度娘的解释我们可以知道，最小生成树(Minimum Spanning Tree, MST)就是：一个有n个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有n个结点，并且有保持图连通的最少的边。简单点来说就是求最小的连通图，就是从一个点能到达图的任意一点，且花费的代价最小（所有边的权值最小）。最小生成树问题通常用于网络设计、电路设计等领域，目的是找到连接所有节点的最低成本方式。常见的算法有克鲁斯卡尔算法（Kruskal）和普里姆算法（Prim）等。
C - Separated Lunch
m0_74304371的博客
10-05 480
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
代码随想录算法训练营day50
qq_56445436的博客
10-07 237
【代码】代码随想录算法训练营day50。
16.最接近的三数之和
weixin_61695887的博客
10-04 339
与三数之和的题类似，首先对数组进行排序。排序后的数组使得我们可以有效地使用双指针法来找到和最接近目标值的三元组。：遍历结束后，返回最接近的三元组的和。，然后通过双指针法来寻找另外两个数。：遍历排序后的数组，固定一个数。中选出三个整数，使它们的和与。假定每组输入只存在恰好一个解。使得三数之和最接近目标值。
python-FILIP/字符串p形编码/数字三角形
2401_83954530的博客
10-04 965
例如：字符串 122344111 可被描述为 1个1、2个2、1个3、2个4、3个1 ，因此我们说122344111 的 p 型编码串为 1122132431；100200300 可描述为 1个1、2个 0、1个2、2个0、1个3、2个0，因此它的 p 型编码串为 112012201320。对于 100% 的数据，100≤a,b≤999，a,b 不含 0 或不为 0。那么该数的翻转同样有 f 位，最高位为为 af​，第二位为 af−1​，……设原数有 f 位，最高位为 a1​，第二位为 a2​，。
算法训练营打卡Day18
Zoe_igxgx的博客
09-29 977
示例 2: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 输出: 5 解释: 节点 5 和节点 4 的最近公共祖先是节点 5。示例 1: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出: 3 解释: 节点 5 和节点 1 的最近公共祖先是节点 3。例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]
第二十一章 （动态内存管理）
code_whiter的博客
10-03 1257
1、栈区：在执行函数的时候，函数内的局部变量的储存单元都可以在栈上创建，函数执行结束的时候这些储存单元自动被释放。当是情况2 的时候，原有空间之后没有⾜够多的空间时，扩展的⽅法是：在堆空间上另找⼀个合适⼤⼩的连续空间来使⽤。c 语言还提供了另一个函数free，是专门用来做动态内存的释放和回收的（一般是要与malloc函数同时使用的），函数原型如下。3.返回类型的是void * ，所以malloc函数并不知道开辟空间的类型，具体在使用者使用的时候自己来选择。2. 数组在申明的时候，必须指定数组的长度，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值