关于冒泡排序和qsort函数，与用冒泡排序思想实现qsort函数的详解（超详细）

目录

1.冒泡排序

 2.qsort函数

qsort函数讲解：

qsort函数运用：

3.用冒泡排序实现qsort函数

---

1.冒泡排序

冒泡排序思想：两两相邻的元素比较，不满足条件就交换

//冒泡排序：左右相邻元素比较
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[10] = {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;
}

实现效果：

---

 

 2.qsort函数

qsort函数讲解：

特点：

1. 采用快速排序的方法

2. 适合任意类型数据的排序

.

qsort函数参数

void qsort(

               void* base, //排序的数组第一个元素地址

               size_t num, //元素个数

               size_t size, //一个元素的大小

               int (*cmp)(const void* e1, const void* e2)

                //函数指针类型，指向的函数能比较base中元素,

                  void*可接收任意类型元素地址，但无法对其进行解引用操作

                );

qsort函数运用：

//void*可接收任意类型元素地址，但无法对其进行解引用操作
int cmp_t(void* e1, void* e2)
{
//使用前按照比较的内容进行“强制类型转换”，再解引用操作
	return *(int*)e1 - *(int*)e2;
}
int main()
{
	int arr[10] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, 10, sizeof(arr[0]), cmp_t);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

实现效果：

---

 

3.用冒泡排序实现qsort函数

 要使用冒泡排序思想实现qsort函数效果，就要使冒泡排序的”主体框架“和”相邻比较“思想不变，进而实现此函数。

为了使bubble_sort函数能像qsort函数一样接收任意元素类型，我们就要对其”函数参数“、”比较方式“、”交换逻辑“进行轻微改动。

1.函数参数：

为达到和qsort函数一致的效果，bubble_sort函数参数设置应和qsort函数一致。

重新修改后的bubble_sort函数参数：

void bubble_sort(
	void *base,//首元素地址
	int num,//元素个数
	int width,//单个元素字节大小
	int(__cdecl *compare)(void* e1, void* e2)
	//函数指针类型，指向的函数能比较base中元素
				)

2.比较方式：

比较方式仍遵循冒泡排序思想，故而其“主体框架”不变，“交换逻辑”发生变化。

void bubble_sort(void *base, int num, int width,
	int(__cdecl *compare)(void* e1, void* e2))
{
	int i = 0;
	//比较趟数
	for (i = 0; i < num - 1; i++)
	{
		int j = 0;
		//相邻两数比较，每次比完少一个数
		for (j = 0; j < num - 1 - i; j++)
		{
			//函数的新比较逻辑
		}
	}
}

3.交换逻辑

为使bubble_sort函数像qsort函数一样适用于任意类型，就要进行“交换逻辑”的变更。

当元素都是int类型时，只需设置同为int类型的tmp变量交换即可。但面对其他类型时，此方法就不可使用，我们则可进行单一字节的交换。

图解：

当两个整形变量进行交换时，先创建一个字节，然后交换四次即可完成。

修改后：

//由于前一步已经进行char*的强制类型转换，所以直接用char*类型接收
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++;
	}
}

void bubble_sort(void *base, int num, int width,
	int(*compare)(void* e1, void* e2))
{
	int i = 0;
	//比较趟数
	for (i = 0; i < num - 1; i++)
	{
		int j = 0;
		//相邻两数比较，每次比完少一个数
		for (j = 0; j < num - 1 - i; j++)
		{
			//函数的新比较逻辑
			//先对base强制类型转换为char*类型
			//然后可依照不同类型元素加不同的width进行“不同类型的相邻元素”比较
			if (compare((char*)base+j*width,(char*)base+(j+1)*width)>0)
			{
				//创建swap函数进行“单一字节交换”
				swap((char*)base + j*width, (char*)base + (j + 1)*width, width);
			}
		}
	}
}

图解swap函数：

实现效果：

以上为用冒泡排序实现qsort函数的详解。

4.代码仓库

http://learn0825(2)/learn0825(2)/0825.c