编写基于冒泡排序算法的qsort函数

目录

1.简单认识冒泡排序

 2.进入正文分析如何实现函数

3.1比较两个相邻元素的大小

3.2比较两个相邻元素大小后要换函数

4.my_qsort函数：

5.总结：

---

1.简单认识冒泡排序

冒泡排序的步骤如下：

• 比较相邻的两个元素，如果第一个元素比第二个元素大（或小），就交换它们的位置。
• 对每一对相邻的元素重复上述操作，直到数组的末尾。这样，最大（或最小）的元素就被移动到了数组的最后一个位置。
• 除了最后一个元素外，对剩余的元素重复以上步骤，直到没有任何一对相邻元素需要交换为止

// 冒泡排序
void bubble_sort(int arr[], int len)
{
	int i, j, temp;
	for (i = 0; i < len - 1; i++)
	{
		for (j = 0; j < len - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

 我们可以基于冒泡排序思想对以上代码进行改造成qsort函数对任意数据类型起到排序作用

了解qsort函数可以看下面的网站或者我的另一篇博客：

cplusplus网站：https://legacy.cplusplus.com/reference/cstdlib/qsort/?kw=qsort

关于qsort函数的使用博客：qsort库函数的使用_Jamo@的博客-CSDN博客

 2.进入正文分析如何实现函数

我们通过观察冒泡函数可以看出我们在最初给的冒泡函数中只能比较整型数据来进行排序

 在冒泡函数中的第二个for循环中我们通过每一趟冒泡来依次比较两个相邻的元素大小来决定是否交换他们的位置，但如果我们在想要排序的数组中遇到了浮点型数据呢？又或是字符型数据呢？又或是结构体类型数据呢？

显然此时的冒泡函数无法解决我们的燃眉之急。

但我们依然可以借助于冒泡的模板来写出自己的qsort函数来解决问题：

• 我们发现在排序时我们只是排序的数据类型不一样了，但排序思想任然是冒泡思想，因此我们做出的改变就是对第二个for循环中的比较方法就行改进。

3.1比较两个相邻元素的大小

对于int 类型数据我们可以通过大于小于来直接比较他们的大小来决定是否交换位置

对于所有类型来说我们可以实现一个比较函数来帮我们解决这个问题：

//在比较两个相邻元素大小时，由于不知道跳过元素有多大，因此在处理不确定数据类型排序时，使用char * 类型和原数据类型size大小来找到冒泡排序的下两对元素
 
 
compar((char*)数据1 , (char*)数据2 )
 

//基于冒泡排序算法的qsort函数
void bubble_qsort(void* base, size_t num, size_t size, int (*compar)(const void* e1, const void* e2))
{
	int i = 0;
	int j = 0;
	int tmp = 0;
	for (i = 0; i < num - 1; i++)
	{
		//为了处理不同数据类型比较方法，此处的排序需要在原来整型数据冒泡排序写法上进行改造
		for (j = 0; j < num - 1 - i; j++)
		{
 
 
 
            //在为比较函数compar找两两元素时，由于不知道跳过元素有多大，因此在处理不确定数据类型排序时，使用char * 类型和原数据类型size大小来找到冒泡排序的下两对元素
 
            //比如说比较元素是int类型时（char*）base加上循环变量j * int类型大小4找到数组首个元素地址，第二个元素地址便是（cahr*）base加上循环变量（j+1）之后 *4 找到第二个元素地址
 
			if (compar((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				//交换
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

 以比较整型数据举例：我们自己使用qsort函数时写出自己想要比较的数据类型的compar函数：

//比较函数
//返回大于0的数字代表前一个元素大于后一个元素
//返回等于0的数字代表前一个元素等于后一个元素
//返回小于0的数字代表前一个元素小于后一个元素
int compar(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}

3.2比较两个相邻元素大小后要换函数

我们通过自己写一个swap函数来解决这一问题;

为什么要自己写交换函数而不用第三个变量来进行两两交换呢？

我们既然是为了写出一个qsort函数比较任意数据类型数据那我们自然也不知道我们将来要交换的元素究竟是什么类型的，自然也无法创建第三个变量来使其两两交换

实现swap函数：

//给swap函数初始化参数与交换函数compar同理
swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
 
//由于不知道交换元素的类型，因此我们决定对相邻两个元素一个字节一个字节进行交换
//将两元素
void swap(char* p1, char* p2, size_t size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *p1;
		*p1 = *p2;
		*p2 = tmp;
		p1++;
		p2++;
	}
}

4.my_qsort函数：

//此交换函数原理是对内存中相邻元素一个字节一个字节交换
void swap(char* p1, char* p2, size_t size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *p1;
		*p1 = *p2;
		*p2 = tmp;
		p1++;
		p2++;
	}
 
}
//比较函数
//返回大于0的数字代表前一个元素大于后一个元素
//返回等于0的数字代表前一个元素等于后一个元素
//返回小于0的数字代表前一个元素小于后一个元素
int compar(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}
 
 
//基于冒泡排序算法的qsort函数
void bubble_qsort(void* base, size_t num, size_t size, int (*compar)(const void* e1, const void* e2))
{
	int i = 0;
	int j = 0;
	int tmp = 0;
	for (i = 0; i < num - 1; i++)
	{
		//为了处理不同数据类型比较方法，此处的排序需要在原来整型数据冒泡排序写法上进行改造
		for (j = 0; j < num - 1 - i; j++)
		{
			//不知道跳过元素有多大，因此在处理不确定数据类型排序时，使用char * 类型和原数据类型size大小来找到冒泡排序的下两对元素
 
			//返回大于0的数字代表前一个元素大于后一个元素
			//返回等于0的数字代表前一个元素等于后一个元素
			//返回小于0的数字代表前一个元素小于后一个元素
			if (compar((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				//交换
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}
int main()
{
	int num_arr[10] = { 10,9,8,7,6,5,4,3,2,1 };
	int sz = sizeof(num_arr) / sizeof(num_arr[0]);
	printf("原来的顺序：");
	print_arr(num_arr, sz);
 
	bubble_qsort(num_arr, sz, sizeof(num_arr[0]), compar);
 
	printf("排序的顺序：");
	print_arr(num_arr, sz);
 
	return 0;
}
 

5.总结：

实现该函数最主要的部分便是交换函数compar函数参数的书写，如何在不知道元素数据类型的情况下找到元素来进行大小比较，以及如何在不知道元素数据类型的情况下对两个相邻元素来交换。

---

以上便是全部内容了，感谢大家的支持和鼓励，下次见！