C：使用冒泡排序模拟实现qsort功能

目录

一、函数介绍：

二、实现冒泡排序

三、修改冒泡函数

四、设计交换函数

五、设计比较函数

六、模拟qsort函数排序int数组实现

七、模拟qsort函数排序结构体数组实现

---

一、函数介绍：

        qsort函数用于对一个数组中相同类型元素进行快速排序，下面来介绍一些qsort函数本身。

(void* base)参数要求传入要处理的数组；（size_t num)参数要求传入数组的长度；（size_t）参数要求传入数组中单个元素的大小；int (*compar)(const void*,const void*)参数是一个函数指针，指向的地址就是用户自己设计的一个比较函数。

二、实现冒泡排序

        冒泡排序逻辑这里就不详细阐述了，直接上代码。

void bubble_sort(int* arr, size_t num)
{
	for (int i = 0; i < num - 1; i++)
	{
		for (int j = 0; j < num - i - 1; j++)
		{
			if (arr[j] > arr[j+1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

三、修改冒泡函数

        因为排序函数不仅仅要排序整型函数，也要排序数组，结构体等函数。但是冒泡排序中的遍历条件是不需要改变的，只需要改变比较方式，因为结构体数组比较不能直接用大于号小于号。

void bubble_sort(void* base, size_t num, size_t size,int(*cmp)(const void* e1, const void* e2))
{//趟数和比较次数都不需要变，只要变比较方式就可以
	int i = 0; int j = 0;
	for ( i = 0; i < num - 1; i++)
	{
		for ( j = 0; j < num - i - 1; j++)
		{
			if (cmp((char*)base+j*size, (char*)base+(j+1)*size) > 0)//void*类型的指针是不能进行加减“1”操作,又因为base指向的是arr的第一个元素的地址，所以使用这种方法
			{
				//交换函数
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

        由上图公式大家可以看到，我将参数进行了调整，因为传入的不一定是整型数组，所以改成void*类型，数组长度和元素大小没有改变，增加了指向用户自己设计的比较函数的函数指针参数。除此之外，if函数内的比较方式也进行了调整，首先因为viod*类型不能直接+-“1”操作，其次，因为传入数组中的元素类型未知。例如下图：

        如果每个元素是int*类型的，每往后增加一次就会跳过4个字节，如果每个元素是char类型的，每往后增加一次就会跳过一个字节，所以因为数组内元素类型不同，所以无法固定将base强转为什么类型进行遍历。那么换个思路，化整为零，就把base强转为char*类型，因为每次都跳过一个字节，那么在此基础上，乘上已经计算好的数组中单个元素的大小，再乘上循环的次数，就可以实现无论数组内是什么类型的元素都可以进行遍历，因为数组中元素大小已经计算出来了，并且会随着类型的改变而改变计算结果。

四、设计交换函数

        因为上一节讲了遍历的方式是化整为零，那么交换方法就不再是简单的用int类型的中间变量进行交换。因为便利的时候是char*类型，那么就用char*进行交换，一个字节一个字节的交换，当两个元素所占的字节全部交换完成，就等同于将两个元素的位置进行了交换。

void swap(char* buf1, char* buf2, size_t size)
{
	int i = 0;
	for ( i = 0; i < size; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

        buf1和buf2是两个要交换元素的地址，size是一个元素的大小。

五、设计比较函数

        这一节就和qsort函数的使用方法一样，要设计一个比较函数，以整型函数为例

int cmp_int(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}

 因为设计者不知道用户进行排序的数组中元素的类型是什么，所以将比较函数的参数设计为，void*类型，我们模拟的时候也要这样。所以，在设计比较函数的是时候就要进行强转操作。

六、模拟qsort函数排序int数组实现

        首先为了更直观的观察结构，先写一下打印函数。之后把对整型数组的排序放到test1中进行调用，结构体排序放到test2进行调用。

#include<stdio.h>
#include<string.h>

void swap(char* buf1, char* buf2, size_t size)
{
	int i = 0;
	for ( i = 0; i < size; i++)
	{
		char tmp = *buf1;//中间变量
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

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

void bubble_sort(void* base, size_t num, size_t size,int(*cmp)(const void* e1, const void* e2))
{//趟数和比较次数都不需要变，只要变比较方式就可以
	int i = 0; int j = 0;
	for ( i = 0; i < num - 1; i++)
	{
		for ( j = 0; j < num - i - 1; j++)
		{
			if (cmp((char*)base+j*size, (char*)base+(j+1)*size) > 0)//void*类型的指针是不能进行加减“1”操作,又因为base指向的是arr的第一个元素的地址，所以使用这种方法
			{
				//交换函数
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

void print_arr(int arr[], int sz)//打印整型数组的函数
{
	int i = 0;
	for ( i = 0; i < sz; i++)
	{
		printf("%d", arr[i]);
	}
	printf("\n");
}

int cmp_int(const void* e1, const void* e2)//整型数组的比较函数
{
	return *(int*)e1 - *(int*)e2;
}

void test1()
{
	int arr[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print_arr(arr, sz);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	print_arr(arr, sz);
}

int main()
{
	test1();//测试排序整型函数
	//test2();//测试结构体排序	
	return 0;
}

 

模拟成功，

七、模拟qsort函数排序结构体数组实现

        下面进行结构体数组排序，此次以年龄的大小进行排序。

#include<stdio.h>
#include<string.h>

void swap(char* buf1, char* buf2, size_t size)
{
	int i = 0;
	for ( i = 0; i < size; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

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

void bubble_sort(void* base, size_t num, size_t size,int(*cmp)(const void* e1, const void* e2))
{//趟数和比较次数都不需要变，只要变比较方式就可以
	int i = 0; int j = 0;
	for ( i = 0; i < num - 1; i++)
	{
		for ( j = 0; j < num - i - 1; j++)
		{
			if (cmp((char*)base+j*size, (char*)base+(j+1)*size) > 0)//void*类型的指针是不能进行加减“1”操作,又因为base指向的是arr的第一个元素的地址，所以使用这种方法
			{
				//交换函数
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

struct Stu//定义结构体
{
	char name[20];
	int age;
};

void print_arr2(struct Stu* arr, int sz)//结构体打印函数
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%s ", (arr+i)->name);
	}
	printf("\n");
}

int cmp_stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;//（struct Stu*）e是将e强转成结构体指针
}

void test2()
{
	struct Stu arr[] = { {"zhangsan", 20},{"lisi", 30},{"wangwu"}, 15};
	int sz = sizeof(arr) / sizeof(arr[0]);
	print_arr2(arr, sz);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
	print_arr2(arr, sz);
}
int main()
{
	//test1();//测试排序整型函数
	test2();//测试结构体排序	
	return 0;
}

 模拟排序成功！