qsort函数的模拟实现（冒泡）

承接上文，下面来使用【冒泡排序】的算法，模拟实现一个排序函数，可以排序任意类型的数据。

一、 咱们还是看一下qsort函数的定义，和如何去使用的。

qsort 底层使用的快速排序
 void qsort( void* base, //待排序数据的起始地址
                        size_t num, //待排序数据的元素个数
                        size_t size, //待排序数据的一个元素的大小，单位是字节
                        int (*compar)(const void*, const void*)//函数指针 - 指向了一个比较函数，这个函数是用来比较2个元素的);
二、首先咱们实现冒泡排序。

#include<stdio.h>
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 - 1 - i;j++)
        {
            //一趟冒泡排序
            int tmp = 0;
            if(arr[j] < arr[j + 1])
            {
                tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}
void print_arr(int arr[],int sz)//自定义打印函数
{
    int i = 0;
    for(i = 0;i < sz ;i++)
    {
        printf("%d ",arr[i]);
    }
    printf("\n");
}
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9};
    int sz = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr,sz);
    print_arr(arr,sz);
    return 0;
}

这里实现的是一组升序整型数组的降序冒泡排序法。

三、咱们用【冒泡排序】的算法，模拟实现一个排序函数，可以排序任意类型的数据。

（1.）首先咱们还得看一下qsort函数的定义；

void qsort( void* base, //待排序数据的起始地址
                        size_t num, //待排序数据的元素个数
                        size_t size, //待排序数据的一个元素的大小，单位是字节
                        int (*compar)(const void*, const void*)//函数指针 - 指向了一个比较函数，这个函数是用来比较2个元素的);

咱们还是以一组整型一维数组举例；

void* base 接收的是待排序数组的起始地址，也就是这个数组的数组名。

size_t num 接收的是待排序元素的个数，可以用sizeof(arr) / sizeof(arr[0])计算。

size_t size 接收的是待排序数据的一个元素的大小，单位是字节，可以用sizeof(arr[0])得到。

最主要的就是这个函数指针，int (*compar)(const void*, const void*)//函数指针 - 指向了一个比较函数，这个函数是用来比较2个元素的)

//int (*cmp)(const void* e1, const void* e2)
//e1是一个指针，存放了一个要比较的元素的地址
//e2是一个指针，存放了一个要比较的元素的地址
//e1指向的元素>e2指向的元素，返回>0的数字
//e1指向的元素==e2指向的元素，返回0
//e1指向的元素<e2指向的元素，返回<0的数字

（2.）由此，咱们可以用【冒泡排序】的算法模拟实现qsort函数。

void bubble_sort(void* base, size_t num, size_t size, int (*cmp)(const void* e1, const void*e2))
{
	//冒泡排序的趟数
	int i = 0;
	for (i = 0; i < num - 1; i++)
	{
		//一趟冒泡排序
		int j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			//if (arr[j] > arr[j + 1]),不用传统的冒泡。
			if(cmp((char*)base + j * size, (char*)base + (j + 1) * size)>0)
			{
				//交换
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

  这里面的if判断它是什么类型，然后把它强转成char指针。然后一个字节一个字节去比。

if(cmp((char*)base + j * size, (char*)base + (j + 1) * size)>0)
			{
				//交换
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}

    我们在这里用到了swap函数，用来交换。在swap函数里面一个字节一个字节交换。

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

（3.）总体实现如下

#include<stdio.h>

void swap(char* buf1, char* buf2, size_t size)
{
    int i = 0;
    for (i = 0; i < size; i++)
    {
        char tmp = *buf1;
        *buf1 = *buf2;
        *buf2 = tmp;
        buf1++;
        buf2++;
    }
}
int cmp_int(const void*e1, const void*e2)
{
	return *(int*)e1 - *(int*)e2;
}
void bubble_sort(void* base, size_t num, size_t size, int (*cmp)(const void* e1, const void*e2))
{
	//冒泡排序的趟数
	int i = 0;
	for (i = 0; i < num - 1; i++)
	{
		//一趟冒泡排序
		int j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			//if (arr[j] > arr[j + 1])
            //你不知道它是什么类型
            //你需要一个字节一个字节的比
            //就要强转char指针
            //然后每次比的时候就需要跳过宽度个单位
			if(cmp((char*)base + j * size, (char*)base + (j + 1) * size)>0)
			{
				//交换
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

void print_arr(int arr[],int sz)//自定义打印函数
{
    int i = 0;
    for(i = 0;i < sz ;i++)
    {
        printf("%d ",arr[i]);
    }
    printf("\n");
}

int main()
{
    int arr[10] = {9,8,7,6,5,4,3,2,1,0};
    int sz = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
    print_arr(arr,sz);
    return 0;
}

到这就结束了，如有不足，请各位大佬在评论区批评指正。