函数原型

qsort - C++ Reference (cplusplus.com)

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

头文件：stdlib.h

功能：对数组中的元素进行排序

• 使用compar函数确定顺序，对base指向的数组的num个元素进行排序，每个元素的大小为size字节。

• 此函数使用的快速排序算法通过调用指定的compar函数并将指向它们的指针作为参数来比较元素对。

• 该函数不返回任何值，但修改由base指向的数组的内容，并按照compar定义对其元素重新排序。

• 等价元素的顺序不定。

参数：

• base：指向要排序数组的第一个对象的指针，该对象已转换为void*。

• num：base指向的数组中的元素个数。size_t是无符号整数类型。

• size：数组中每个元素的大小（字节）。

• compar：指向比较两个元素的函数指针。qsort反复调用此函数以比较两个元素。应遵循以下原型：
  int compar (const void* p1, const void* p2);

  将两个指针作为参数（都转换为const void*）。通过返回值定义元素的顺序：

  返回值	含义
  <0	p1指向的元素位于p2指向的元素之前
  0	p1指向的元素与p2指向的元素等价
  >0	p1指向的元素位于p2指向的元素之后

int数组元素排序

#include <stdio.h>
#include <stdlib.h>
int cmp_int(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;	//e1-e2为升序，e2-e1为降序，注意都要转换为int*，然后解引用取得对应的元素
}
void print_arr(int arr[], int sz)
{
	int i;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
int main()
{
	int arr[] = { 2,8,6,7,5,4,3,9,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	print_arr(arr, sz);
	return 0;
}

结构体数组元素排序

#include <stdio.h>
#include <stdlib.h>
struct Stu
{
	char name[20];
	int age;
	float score;
};
void print_stu(struct Stu arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%s %d %f\n", arr[i].name, arr[i].age, arr[i].score);
	}
	printf("\n");
}
int cmp_stu_by_socre(const void* e1, const void* e2)
{
	if (((struct Stu*)e1)->score > ((struct Stu*)e2)->score)
		return 1;
	else if (((struct Stu*)e1)->score < ((struct Stu*)e2)->score)
		return -1;
	else
		return 0;
}
int cmp_stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
int cmp_stu_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
int main()
{
	struct Stu arr[] = { {"zhangsan",20,87.5f},{"lisi",22,99.0f},{"wangwu", 10, 68.5f} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_socre);
	//qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
	print_stu(arr, sz);
	return 0;
}

• 可以写多个compar函数分别按照结构体中不同类型的成员排序。

  • score由于是float类型，所以可以通过常规关系运算符比较，分别返回1或-1或0。

  • name由于是字符串，所以可以通过strcmp函数比较。

冒泡排序模拟qsort

冒泡排序简介

• 每趟从第一对相邻元素开始进行比较，如果第一个比第二个大（小），那么就交换它们两个。
• 每趟都能将一个元素放到正确的位置
• 重复以上步骤（除了已排序的部分）

一个简单的冒泡排序：

#include <stdio.h>
void bubble(int* arr, int sz)
{
	int i, j, tmp;
	for (i = 0; i < sz - 1; i++)
	{
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 2,6,9,3,7,5 };
	int sz = sizeof(arr)/sizeof(arr[0]);
	bubble(arr, sz);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

模拟qsort

qsort使用的是快速排序算法，但我们可以通过模拟qsort的参数实现一个通用的冒泡排序：

void Swap(char* buf1, char* buf2, int width)
{
	int i;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
void bubble_sort(void* base, int sz, int width, int (*cmp)(const void* e1, const void* e2))
{
	int i, j;
	for (i = 0; i < sz - 1; i++)
	{
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
		}
	}
}

• 由于原本e1就在e2的前面，而只有cmp函数的返回值>0时，才需要把e1排到e2的后面，所以只有当cmp的返回值>0时才需要交换。

• base参数需要转换为char*，因为char*指针±1都只跳过1个字节，灵活度最高，适合各种大小的元素。

• Swap函数通过传入char*指针和每个元素的大小来逐字节交换；