冒泡排序实现库函数qsort，啥都可以排序

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

void b_qsort(int arr[],int n) {//冒泡排序int数组   
	for (int i = 0; i < n; i++) 
	{
		for (int j = 0; j < n - i - 1; j++)
		{
			if (arr[j] > arr[j + 1]) {
				int tem = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tem;
			}
		}
	}
	for (int i = 0; i < n; i++) {
		printf("%d ", arr[i]);
	}
}



test0() {   //输入5，输入五个数，排序
	int n = 0;
	int a[5] = { 0 };
	scanf("%d", &n);
	for (int i = 0; i < 5; i++) {
		scanf("%d", &a[i]);
	}
	int len = sizeof(a) / sizeof(a[0]);
	b_qsort(a, len);
}

//***********************************************************
//冒泡函数实现数组排序

void show_arr(int* arr, int sz) {//打印函数
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n--------------------------------\n");
}

void bubble_sort(int* arr, int sz) {//冒泡排序
	for (int i = 0; i < sz - 1; i++)
	{
		for (int 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;
			}
		}
	}
	
}


void test1() {
	int arr[] = { 5,3,8,7,1,6,9,4,2,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	printf("冒泡排序：");
	bubble_sort(arr, sz);
	show_arr(arr, sz);
}
//qsort排序整型-----------------------------------------------
int cmp_int(const void* e1, const void* e2) {
	return *(int*)e1 - *(int*)e2;
}

void test2() {
	int arr[] = { 5,3,8,7,1,6,9,4,2,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	printf("qsort排序：");
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	show_arr(arr, sz);
}

//--------------------------------------------------------------
//qsort排序结构体--按照名字

struct stu
{
	char name[20];
	int age;
};

void cmp_stu_name(const void*e1,const void*e2)
{
	return strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name);
}

void test3() //qsort排序，按照name排序
{
	struct stu s[] = { {"zhangsan",22},{"lisi",55},{"wangwu",80} };
	int sz = sizeof(s) / sizeof(s[0]);
	struct stu* p = &s;
	qsort(s, sz, sizeof(s[1]), cmp_stu_name);
	for (int i = 0; i < sz; i++) {
		printf("%s %d\n", p->name,p->age);
		p++;
	}
	
}
//----------------------------------
//qsort排序结构体----按照年龄大小

void cmp_stu_age(const void* e1, const void* e2)
{
	return ((struct stu*)e1)->age-((struct stu*)e2)->age;
}
void test4()
{
	struct stu s[] = { {"zhangsan",22},{"lisi",55},{"wangwu",80} };
	int sz = sizeof(s) / sizeof(s[0]);
	struct stu* p = &s;
	qsort(s, sz, sizeof(s[1]), cmp_stu_age);
	for (int i = 0; i < sz; i++) {
		printf("%s %d\n", p->name, p->age);
		p++;
	}

}
//-------------------------------------------
//改造冒泡排序为qsort,啥类型都能排序

void Swap(char* buf1, char* buf2, int width) {  //改造冒泡排序中的交换函数，按照字节进行交换
	for (int i = 0; i < width; i++) {          //每轮交换一个类型为width宽度的值
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}


void q_bubble_sort(void* base,int sz,int width,int (*cmp)(const void* e1,const void* e2)) {
	for (int i = 0; i < sz - 1; i++)//改造后的冒泡排序，按照qsort改的
	{
		for (int 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);
			}
		}
	}

}

void test5()//改造后的冒泡排序按照年龄排序
{
	struct stu s[] = { {"zhangsan",22},{"lisi",55},{"wangwu",80} };
	int sz = sizeof(s) / sizeof(s[0]);
	struct stu* p = &s;
	q_bubble_sort(s, sz, sizeof(s[1]), cmp_stu_age);
	for (int i = 0; i < sz; i++) {
		printf("%s %d\n", p->name, p->age);
		p++;
	}

}
void test6()//改造后的冒泡排序按照name排序
{
	struct stu s[] = { {"zhangsan",22},{"lisi",55},{"wangwu",80} };
	int sz = sizeof(s) / sizeof(s[0]);
	struct stu* p = &s;
	qsort(s, sz, sizeof(s[1]), cmp_stu_name);
	for (int i = 0; i < sz; i++) {
		printf("%s %d\n", p->name, p->age);
		p++;
	}

}

int main() {
	//test0();
	/*test1();
	test2();
	test3();
	test4();*/
	test5();
	test6();
	
}

纯属个人练习，仅供参考。

解析一下

 上面为c++里面的qsort解释

void qsort(void*base,size_t num,size_t size,int(*compar)(const void*,const void *))

调用qsort函数排序，

（）中需要  base（指针），指向数组（结构体）或其他类型

size_t num    传入的是数组长度（sizeof（a）/sizeof（a[ 0 ]））

size_t size    传入的是数组内数据类型的长度 （一般用关键字sizeof（）计算数据类型大小）

int(*compar)(const void*,const void *)

传入能够排序数组的函数，两个const void*分别指向要排序比较的数值，通过比较函数

返回值判断二者大小，在进行排序

>0，前大于后

=0，前等于后

<0，前小于后

排序后是从小到大的顺序

若需要从大到小则改变前后顺序即可

void cmp_stu_age(const void* e1, const void* e2)//从小到大排序
{
	return ((struct stu*)e1)->age-((struct stu*)e2)->age;
}
void cmp_stu_age(const void* e1, const void* e2)//从大到小排序
{
	return ((struct stu*)e2)->age - ((struct stu*)e1)->age;
}

 就说到这吧！！！