qsort函数的使用及模拟实现

最新推荐文章于 2024-06-15 23:36:03 发布

谦逊码农的旅程

最新推荐文章于 2024-06-15 23:36:03 发布

阅读量870

点赞数 30

分类专栏： C语言文章标签：算法 c语言数据结构

本文链接：https://blog.csdn.net/2201_75582674/article/details/136419550

版权

C语言专栏收录该内容

23 篇文章 0 订阅

订阅专栏

qsort函数的定义

在MSDN上查找qsort函数的定义如下：

Remarks

The qsort function implements a quick-sort algorithm to sort an array of num elements, each of width bytes. The argument base is a pointer to the base of the array to be sorted. qsort overwrites this array with the sorted elements. The argument compare is a pointer to a user-supplied routine that compares two array elements and returns a value specifying their relationship. qsort calls the compare routine one or more times during the sort, passing pointers to two array elements on each call:

compare( (void *) elem1, (void *) elem2 );

翻译过来意思是：

qsort函数实现了一个快速排序算法，用于对一个包含num个元素、每个元素宽度为width的数组进行排序。参数base是指向待排序数组基地址的指针。qsort会用排好序的元素覆盖这个数组。参数compare是指向用户提供的比较两个数组元素并返回它们关系的函数的指针。在排序过程中，qsort会多次调用compare函数，每次传递两个数组元素的指针。

所以qsort函数的参数简单的表示如下：

qsort(待排数组首元素地址，数组的长度，数组中一个元素所占的空间，函数指针)

其中函数是需要我们自己提供
函数的返回值必须要遵循以下规则：

表示elem1 小于 elem2 就返回一个小于0的数；如果相等则返回0；如果elem1 大于 elem2 则返回一个大于0的数。

只有返回值大于0时才进行交换。

使用qsort函数的原因

qsort函数是一个通用的排序函数，有以下几个优点：

灵活性：qsort函数可以用于对任意类型的数组进行排序，只需要提供一个适当的比较函数即可。这使得它非常灵活，可以适用于各种不同类型的数据结构。

高效性：快速排序算法是一种高效的排序算法，具有较好的平均时间复杂度。qsort函数使用了快速排序算法，因此在大多数情况下，它能够提供较高的排序性能。

可定制性：通过提供自定义的比较函数，可以根据具体需求对元素进行排序。这使得使用qsort函数可以根据不同的排序规则进行排序，例如按照数字大小、字母顺序或者自定义的特定规则。

易于使用：qsort函数的使用相对简单，只需提供待排序数组的基地址、元素个数和比较函数即可完成排序操作。

qsort使用举例

1.使用qsort函数排序整型数据

#include <stdio.h>
int compareNum(const void* a1, const void* a2) {
	return *(int*)a1 - *(int*)a2;//返回值可能大于0，可能小于0，可能等于0
}
void print(int* arr, int sz) {
	for (int i = 0; i < sz; i++) {
		printf("%d ", arr[i]);
	}
}
int main()
{
	int arr[] = { 1,5,7,2,3,9,4,6,0,8 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int num = sizeof(arr[0]);
	qsort(arr, sz, num, compareNum);
	print(arr, sz);
	return 0;
}

2.使用qsort函数排序结构数据

#include <stdio.h>
#include <string.h>
struct stu {
	char name[20];
	int age;
};
int compareByAge(const void* e1, const void* e2) {
	return ((struct stu*)e1)->age - ((struct stu*)e2)->age;
}
int compareByName(const void* e3, const void* e4) {
	return strcmp(((struct stu*)e3)->name, ((struct stu*)e4)->name);
}
void test1() {
	struct stu p1[] = { {"zhangsan",19}, {"lisi",20}, {"liwang",17} };
	int sz = sizeof(p1) / sizeof(p1[0]);
	qsort(p1, sz, sizeof(p1[0]), compareByAge);
}
void test2() {
	struct stu p1[] = { {"zhangsan",19}, {"lisi",20}, {"liwang",17} };
	int sz = sizeof(p1) / sizeof(p1[0]);
	qsort(p1, sz, sizeof(p1[0]), compareByName);
}

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

上述代码中要注意当排序名字时，要使用strcmp函数进行比较大小。

strcmp函数的返回值如下：

可看出strcmp函数的返回值满足qsort函数的要求。使用strcmp函数要包含头文件 #include <string.h>

qsort函数的模拟实现

模仿qsort的功能实现一个通用的冒泡排序

qsort函数底层使用的是快速排序的方式，下面用冒泡排序的方式进行模拟。

对整型数据的模拟：

#include <stdio.h>
int comepareNum(const void* p1, const void* p2) {
	return *(int*)p1 - *(int*)p2;
}
void swap(char* e1, char* e2, int width) {
	for (int i = 0; i < width; i++) {
		char temp = *e1;
		*e1 = *e2;
		*e2 = temp;
		e1++;
		e2++;
	}
}
void bubbleSort(void* base, size_t sz, size_t num, int (*cmp)(const void*, const void*)) {
	for (int i = 0; i < sz - 1; i++) {
		for (int j = 0; j < sz - 1 - i; j++) {
			if (cmp((char*)base + j * num, (char*)base + (j+1) * num) > 0) {
				swap((char*)base + j * num, (char*)base + (j + 1) * num, num);
			}
		}
	}
}
int main() {
	int arr[] = { 1,5,7,2,3,9,4,6,0,8 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubbleSort(arr, sz, sizeof(arr[0]), comepareNum);
	for (int i = 0; i < sz; i++) {
		printf("%d ", arr[i]);
	}
	return 0;
}

void bubbleSort(void* base, size_t sz, size_t num, int (*cmp)(const void*, const void*)) {
   for (int i = 0; i < sz - 1; i++) {
       for (int j = 0; j < sz - 1 - i; j++) {
           if (cmp((char*)base + j * num, (char*)base + (j+1) * num) > 0) {
               swap((char*)base + j * num, (char*)base + (j + 1) * num, num);
           }
       }
   }
}

void* base是数组元素的首地址，sz 是base数组的长度，num 是数组中一个元素所占的空间，int (*cmp)(const void*, const void*)是我们所创建的函数的指针。

我们是模拟实现qsort函数，所以我们假设我们不知道数组的类型。

在这块代码中，因为形参中数组的首元素的地址类型为void*类型，void*类型不能解引用，不能直接对 void* 指针进行指针算术运算，因为其指向的类型大小未知。如果需要进行指针算术操作，应先将 void* 指针转换为具体类型的指针，再进行计算。

由于我们不知道数组的类型，所以我们将数组base强制类型转换为 char* 类型，char*类型只占一个字节，(char*)base表示base数组中第一个元素中的第一个字节，加一个num表示下一个元素中的第一个字节。

假设数组中的第一个元素是一个整型占4个字节：

加一个num表示下一个元素中的第一个字节：

void swap(char* e1, char* e2, int width) {
   for (int i = 0; i < width; i++) {
       char temp = *e1;
       *e1 = *e2;
       *e2 = temp;
       e1++;
       e2++;
   }
}

e1 表示一个元素的第一个字节，e2 表示下一个元素的第一个字节

上述代码表示一个字节一个字节的交换，每一对交换后，移动到下一个字节的位置再进行交换，直到循环到width（数组中一个元素的所占的空间大小）停止，循环结束后这两个元素也就互相交换完成了。

完