冒泡排序模拟实现qsort函数

我们知道，qsort是使用的快速排序来帮助我们进行排序，为了帮助初学者更好地理解qsort函数，我们今天使用冒泡排序来模拟一个函数实现qsort的功能：

我们首先先看qsort的参数：

qsort具备四个参数，第一个参数void*base指的是用void*来接受我们想要排序的目标数组的起始地址。

第二个参数size_t num指的是这个数组的元素个数，size_t size是这个数组中一个元素的大学（字节），我们通常用sizeof来计算。

qsort函数最重要的一个参数， int (*compar)(const void*,const void*))，是一个函数指针，指向一个函数，这个函数是我们使用者自己提供的，用来比较这个目标数组中两个元素大小。 

当然这个函数的返回值必须满足以下条件

分析完qsort的形参之后，我们就开始尝试用冒泡排序来模拟实现qsort的功能。

以下是一个经典的冒泡排序：

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 - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 3,1,7,5,8,9,0,2,4,6 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	return 0;
}

我们先看一下bubble_sort这个函数的代码，由于qsort函数可以比较任意类型的大小，但bubble_sort的if条件语句中，条件语句的判断靠的是整形计算大小，那我们应该怎么修改这个条件语句，让任意类型的数据都能通过大小比较进入语句呢？

很显然，这里就要靠形参函数指针了，在qsort函数中的函数指针指向一个由使用者自己提供的一个函数，这个函数的作用是比较数组两个元素的大小。

也就是说，为了实现比较任意类型的大小，我们在bubble_sort（以下简称bbs）函数中也应引入这个形参，用来比较数组两个参数的大小关系。

于此同时，想要接受各种类型的数组，我们就不能继续让形参的类型为int arr[ ]，而是应该用void* arr来接收（void*指针可以接受各种类型的地址）

void bubble_sort(void* arr, int sz)

同样的原因，当我们提供函数comper，形参也应该是void*类型，为了防止将元素大小改变，我们可以用const 修饰void*指针

int comper(const void* x,const void* y)

 我们的bubble_sort函数就可以写成这样：

void bubble_sort(void* arr, size_t sz,int (*comper)(const void* x,const void* y))
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - i - 1; j++)
		{
			if (comper())
			{
				
			}
		}
	}
}

我们通过comper函数返回真或假，来进入if条件语句。

根据qsort的参数设定，comper函数返回值应该满足 

我们这里以整形数组 为例，那么comper函数就可以定义为：

int comper(const void* x,const void* y)
{
  return *(int*)x-*(int*)y;
}

定义完那bbs函数就可以改成： comper函数后，根据冒泡排序的原理，我们应该比较每个元素的大小并选择交换，所以如何使每一次j循环进入，比较的两个元素的下标都增加1呢？

这个时候，qsort的第三个形参就起到了作用。

我们传递一个元素的大小（后称size）（单位字节）进入函数，通过增加j个单位元素大小size，就可以实现元素的向后移动。

但这样子的话，指针类型就必须是char*，否则j*size就不会刚刚好移动到下一元素的地址上面。

void bubble_sort(void* arr, size_t sz,size_t size,int (*comper)(const void* x,const void* y))
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - i - 1; j++)
		{
			if (comper((char*)arr+j*size,(char*)arr+(j+1)*size)
			{
				;
            }
		}
	}
}

 同理，为了交换不同类型的元素，我们可以写个swap函数接受强制类型转化为char*的arr值，并完成交换。为了处理不同类型，我们直接一字节一字节的交换，这样就凸显出char类型的重要性了,于是除了两个代表字节的参数指针外，我们还需要提供这个类型一个元素所占大小size。

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

将swap函数加入bbs中： 

void bubble_sort(void* arr, size_t sz,size_t size,int (*comper)(const void* x,const void* y))
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - i - 1; j++)
		{
			if (comper((char*)arr+j*size,(char*)arr+(j+1)*size)
			{
				swap((char*)arr+j*size,(char*)arr+(j+1)*size,size);
            }
		}
	}
}

这样一来，我们模拟的bbs函数就差不多成功了。

全部代码如下：

int comper(const void* x, const void* y)
{
	return (*(int*)x) - (*(int*)y);
}


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

void bubble_sort(void* arr, size_t sz, size_t size, int (*comper)(const void* x, const void* y))
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - i - 1; j++)
		{
			if (comper((char*)arr + j * size, (char*)arr + (j + 1) * size) > 0)
			{
				swap((char*)arr + j * size, (char*)arr + (j + 1) * size, size);
			}
		}
	}
}




void test1()
{
	int arr[10] = { 4,6,2,7,9,6,1,5,3,8 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	/*qsort(arr, sz, sizeof(arr[0]), comper);*/
	bubble_sort(arr, sz, sizeof(arr[0]), comper);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}



int main()
{
	test1();
	
	return 0;
}

运行一下：