qsort的模拟实现(详解版）

小高2024

已于 2024-03-03 19:00:18 修改

阅读量1.5k

点赞数 41

文章标签：算法排序算法

于 2024-03-03 18:54:19 首次发布

本文链接：https://blog.csdn.net/m0_73425221/article/details/136435086

版权

在C语言中，想实现排序，qsort无疑是很好的选择，但是qsort究竟如何使用？qsort为什么可以对任意数据类型进行排序？qsort又是如何进行编写的？针对以上问题，我将进行解答。

1.如何正确使用qsort

这是cplusplus上对于qsort的解释。在这里面，我们有以下几点需要注意：

qsort的返回值是void
qsort函数里的四个参数分别是：

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

3. 第一个参数void*base 代表的指向要排序的数组的第一个对象的指针

第二个参数 size_t num代表的是数组中的元素的数目，无符号整数类型。

第三个参数size_t size代表的是数组元素每个元素的大小（以字节为单位),无符号整数类型。

第四个参数 int(*compar)(const void*,const void*)是指向比较两个元素的函数的指针（本质是指针）。

2.qsort的模拟实现

了解了qsort是如何使用的，我们就会自然而然地想出一个问题：

既然qsort这么好用，那设计出qsort的程序员是如何写出qsort的代码，能让存储任何数据类型的数组内部的元素都能进行排列？

首先我们从冒泡排序入手：

int *bubble_sort(int arr[], int len) {
    int temp;

    for (int i = 0; i < len - 1; i++) {
        for (int j = 0; j < len - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        printf("第%d次循环排序后结果：", i + 1);
        for (int k = 0; k < len; k++) {
            printf("%3d", arr[k]);
        }
        printf("\n");
    }
    return arr;
}

我们了解了冒泡排序的工作原理。借用冒泡排序的思路，下面我将通过代码介绍qsort的模拟实现：

第一步：写出主函数

int main()
{
	int arr[] = { 10,9,8,7,6,5,4,3,2,1 };     //定义整型数组并初始化
	int sz = sizeof(arr) / sizeof(arr[0]);    //计算数组长度
	int i = 0;
	bubble_sort(arr, sz, sizeof(arr[0]), cmp);    //模拟qsort函数实现冒泡排序
	for (i = 0; i < sz; i++)                   
	{
		printf("%d ", arr[i]);                     //排序完后对数组进行打印，验证排序是否成功
	}
}

第二步：实现排序函数

void bubble_sort(void* arr, int sz, int width, int(*cmp)(void* e1, void* e2))
{
	int i = 0;
	int j = 0;
	for (i = 0; i < sz - 1; i++)
	{
		//冒泡排序趟数
		for (j = 0; j < sz - 1 - i; j++)   //每一趟冒泡排序
		{
			if (cmp((char*)arr + (j * width), (char*)arr + (j + 1) * width)>0)
			{
				//符合条件进行交换
				swap((char*)arr + (j * width), (char*)arr + (j + 1) * width,width);
			}
		}
	}
}

代码讲解：

1）bubble_sort函数定义时，括号里的arr需要赋予它void*类型，因为编写模拟实现代码的程序员不知道用户想要传递什么类型。

2）bubble_sort函数定义时，最后一个参数:int(*cmp)(void*e1,void*e2),代表的是函数指针，cmp本质是指针，指针指向函数。而函数返回类型是int，函数的参数分别为：void*e1和void*e2,它们是两个无类型的指针，后续会对他们进行强制类型转换的操作。

3）由于不知道用户提供的数组内部元素类型是什么，所以我们不能直接对元素里的数据进行大小比较，而应该使用函数即代码中的cmp进行判断。

4）同理，在交换的时候，也应该另外编写交换函数的代码进行交换，即代码里的swap函数。

需要注意的是，在swap函数里，我们对于传入的两个指针，需要对他们进行char*的强制转换，保证无论用户传入什么数据都能够进行交换（使用char*而不是用其他类型是因为：char*类型的指针在移动时，是以一个字节为单位进行移动，这样的话无论用户传入的是什么类型，都能实现交换；相反，如果是强转成int*，当对指针进行移动的时候，是以四个字节为单位进行移动，用户如果这时候传进去的数组元素是char类型的话，指针一次移动四个字节，会直接跳过四个元素，造成遗漏）。

第三步：实现比较函数cmp

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

注意：void*类型的指针不能进行解引用，在这里面需要进行强制类型转换的操作。

第四步：实现交换函数swap

void _swap(void *p1, void * p2, int size)
{
 int i = 0;
 for (i = 0; i< size; i++)
 {
 char tmp = *((char *)p1 + i);
 *(( char *)p1 + i) = *((char *) p2 + i);
 *(( char *)p2 + i) = tmp;
 }
}

注意：for循环一次，交换的是一个字节，交换的次数取决于数组元素类型所占的字节大小。

最后，附上整个程序的代码。

#include <stdio.h>

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

void _swap(void *p1, void * p2, int size)
{
 int i = 0;
 for (i = 0; i< size; i++)
 {
     char tmp = *((char *)p1 + i);
     *(( char *)p1 + i) = *((char *) p2 + i);
     *(( char *)p2 + i) = tmp;
 }
}
void bubble(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++)
     {
         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(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
 for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
 {
     printf( "%d ", arr[i]);
 }
 printf("\n");
 return 0;
}