冒泡排序及qsort实现

冒泡排序的核心思想就是：两两相邻的元素进行比较。

假设有一个数组，它是**：8 3 2 7 10 9 1 0 7 4**

现在我们要通过两两对比的方式将其升序排列。

我们要先将第一个和第二个对比，如果第一个数较大的话就交换位置。也就是说我们首先要将8和3对比然后交换位置，现在我们的数组就变为了3 8 2 7 10 9 1 0 7 4.

现在我们将第二个和第三个对比，8要大于2，所以8和2交换位置，现在我们的数组就变为了3 2 8 7 10 9 1 0 7 4.（这里3比2大，但是我们会向下继续比较，也就不会再管3和2谁大谁小了）

也就是说，我们要先比较下标0和下标1的数字，然后比较下标1和2的数字，再之后是3与4 4与5 5与6 6与7 7与8 8与9 9与10 下标的数字依次进行比较。

因此，我们要通过循环的方式来进行这段代码

cpp 复制代码

for (int j = 0; j < 10; j++)
{
	if(arr[j] > arr[j + 1])
	{
		int tmp = arr[j];
		arr[j] = arr[j + 1];
		arr[j + 1] = tmp;
	}
}

现在，我们继续分析，经过这轮比较，每次比较中较大的数都会向右移动一位，这轮比较结束后，最右边的数字一定是目前数字中最大的数字，但是中间9个数字的大小却无法确定，如果你不能理解的话，可重读一遍上面的红字。

现在我们可以得知，只经过一次循环遍历是无法让数组有序的，但是可以让数字的最后一个元素最大。那么，如果我们剔除掉最后一个数字，再遍历一遍这个数组，是否就可以让倒数第二个数字最大了呢？如此循环往复，当我们第九次遍历的时候，是不是就可以让倒数第二个是最大的了呢，那么，我们整个的数组就有序了！

好，那么我们来写一下代码。

cpp 复制代码

	for (int i = 0; i < 10; i++)
	{
		for (int j = 0; j < 10-i; j++)//每次都可以少比较一个数
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}

现在我们实现了一个冒泡排序，但是如果我给的数字是1 2 3 4 5 6 7 8 9 10的话，用上面的代码再进行排序，还是要进行一轮又一轮的比较才可以，即便它并不需要交换。所以我们的这段代码还是有一定优化空间的。

怎么优化呢？

数组如果一轮下来是不是就没有交换了呢？那么我们是不是可以定义一个变量来判断数组是否有序呢？说干就干！我们来写一下。

cpp 复制代码

	for (int i = 0; i < 10; i++)
	{
		int flag = 1;//flag来标志是否进行了交换
		for (int j = 0; j < 10-i; j++)//每次都可以少比较一个数
		{
			if (arr[j] > arr[j + 1])
			{
				flag = 0;//如果交换了就置为0
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
	
		}
		if (flag == 1)//没交换即有序，退出即可。
				break;
	}

现在我们来把他包装称为一个函数。我们先来思考以下两个个问题

如何在函数内部更改main函数中的数组内容--->传址调用

2.函数需要几个参数-->数组和数组长度

好，有了这些，我们就来真刀阔斧的大干一场。

cpp 复制代码

void bubble_sort(int* arr, int sz)
{
	for (int i = 0; i < sz-1; i++)
	{
		int flag = 1;
		for (int j = 0; j < sz-1- i; j++)//每次都可以少比较一个数
		{
			if (arr[j] > arr[j + 1])
			{
				flag = 0;
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
		if (flag == 1)
			break;
	}
}
int main()
{
	int arr[] = { 8,3,2,7,10,9,1,0,7,4};
	int sz = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, sz);
	for (int i= 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

现在我们就完成了一次冒泡排序。下面我们来介绍下qsort函数。

qsort函数是C标准库中提供的一个用于排序的函数。

qsort函数的原型如下

cpp 复制代码

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

qsort 函数的第一个参数 base 是需要排序的数组的起始地址，它可以是一个指向数组首元素的指针。

nmemb 是数组中元素的个数。

size 是每个元素的大小，以字节为单位。

compar 是一个函数指针，它指向一个比较函数，这个函数在后续判断了我们是升序排列还是降序排列。函数写法如下：

cpp 复制代码

int cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}

现在我们来实践一下这个函数。

cpp 复制代码

#include <stdio.h>
#include <stdlib.h>
int cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}
int main()
{
	int arr[] = { 8,3,2,7,10,9,1,0,7,4 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

那么现在我们来写一下这个函数叭！

我会以注释的形式解释代码细节，请大家研读代码。

cpp 复制代码

//交换函数
void swap(void* p1, void* p2, int size)//size是元素的大小
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		//由于我们的这个函数要能够交换全部类型的元素
        //所以我们强转为char*类型的，一个地址一个地址的交换
        //是多大字节的类型，我们就每次交换多少个字节的地址内容。
		char tmp = *((char*)p1 + i);
		*((char*)p1 + i) = *((char*)p2 + i);
		*((char*)p2 + i) = tmp;
	}
}
//qsort主体
void bubble_qsort(void* base, int count, int size, int(*cmp)(void*, void*))
{
	int i = 0;
	int j = 0;
	//冒泡排序
	for (i=0; i < count - 1; i++)
	{
		for (j=0; j < count - i - 1; j++)
		{     //如果比较函数cmp大于0，则交换位置。
			  //当然也可以cmp小于0，交换位置。
			  //通过这个的改变来改变升降序.
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{    
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}
int main()
{
	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
	int i = 0;
	bubble_qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), cmp);
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}