沃梦达 / 编程技术 / 编程语言 / C/C++开发 / 正文

C语言中qsort函数用法及用冒泡排序实现

C/C++开发
2023-06-26

qsort函数是由C语言提供的标准库函数,它的实现思想是快速排序。这篇文章主要介绍了C语言中qsort函数用法及用冒泡排序实现qsort函数功能，需要的可以参考一下

一、qsort函数简介

qsort函数是由C语言提供的标准库函数, 它的实现思想是快速排序，qosrt函数的头文件是stdlib.h。

qsort函数可以排序任意类型的数组。它的返回类型是void，参数是(void* base,size_t num,size_t size,int(*compar)(const void* e1,const void* e2))。

接下来对它的参数进行分析：

参数void* base中base是void*类型的指针，base指向待排序数组的第一个元素的地址，也就是指向数组的起始位置。

参数size_t num中size_t表示的是无符号整型，num表示的是待排序数组中总的元素个数。

参数size_t size中size表示的是待排序数组中每个元素占几个字节。

参数int (*compar)(const void* e1, const void* e2)是函数指针，int表示指向函数的返回类型是int类型，compar表示的是函数指针变量，指向函数的地址，被指向的函数用于比较两个元素的大小。

在参数int (*compar)(const void* e1, const void* e2)中，函数指针变量compar指向的函数返回类型是int，返回值的大小可以分为三种情况：

返回值条件
>0e1>e2
<0e1<e2
=0e1=e2

二、qsort函数的使用

1.整型数组排序

#include <stdio.h>
#include <stdlib.h>
int cmp_int(const void* e1, const void* e2)
{
    return *((int*)e1) - *((int*)e2);//默认是升序，将return中e1和e2的位置交换可以使其降序
    //无法对void*类型的指针进行具体操作，因此要将其强制类型转换为int*,使其能够在解引用时访问到4个字节
}
int main()
{
    int i = 0;
    int arr[] = { 7,8,9,4,5,6,1,2,3,10 };
    int sz = sizeof(arr) / sizeof(arr[0]);//计算整型数组中有多少个元素
    qsort(arr, sz, sizeof(int), cmp_int);//sizeof(int)是用来计算int类型的数据所占字节数
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);//输出为1 2 3 4 5 6 7 8 9 10
    }
    return 0;
}

注意：当函数的形参为void*类型，要对其进行具体操作时，应该将其强制类型转换为所需的指针类型

2.字符串排序

#include <stdio.h>
#include <stdlib.h>
int cmp_char(const void* e1, const void* e2)//字符串排序
{
    return strcmp((char*)e1, (char*)e2);//比较字符大小用strcmp
}
int main()
{
    char arr[] = "badecf";
    int i = 0;
    //int sz = sizeof(arr) / sizeof(arr[0]);//sizeof求字符串长度会将\0算进去,也就是实际计算出来的会比数组中的多1。
    int sz = strlen(arr);//strlen是用来计算字符串长度的，且只能用来计算字符串的长度。
    qsort(arr,sz , sizeof(char), cmp_char);
    printf("%s\n", arr);//abcdef
    return 0;
}

3.字符串长度排序

#include <stdio.h>
#include <stdlib.h>
int cmp_char_strlen(const void* e1, const void* e2)//比较字符串长度
{
    return strlen(*(char**)e1) - strlen(*(char**)e2);//先将e1和e2强制类型转换成为char**类型，再解引用取出数组中字符串的地址，计算字符串长度
}
int main()
{
    //char* arr[] = {"abcdef" "abc","defs" };
    //也可以通过下面的方式来写指针数组，下面的4行和上面的这一行作用一样
    char* arr1 = "abc";
    char* arr2 = "abcd";
    char* arr3 = "abcdef";
    char* arr[] = { arr1,arr2,arr3 };
    int i = 0;
    qsort(arr, 3, sizeof(char*), cmp_char_strlen);
    for (i = 0; i < 3; i++)
    {
        printf("%s\n", arr[i]);//输出结果为 abc  defs  abcdef
    }
    return 0;
}

4.浮点型数组排序

#include <stdio.h>
#include <stdlib.h>
int cmp_float(const void* e1, const void* e2)//浮点型数组排序
{
    //return (int)(*(float*)e1 - *(float*)e2);//可能会出错，如12.002和12.001比较之后再强制类型转换为int类型后，结果为0
    if (*(float*)e1 - *(float*)e2 > 0.000000)
    {
        return 1;//当e1>e2时，返回大于0的数
    }
    if (*(float*)e1 - *(float*)e2 < 0.000000)
    {
        return -1;//当e1<e2时，返回小于0的数
    }
    else
        return 0;//当e1和e2相等时，返回等于0的数
}
int main()
{
    float arr[3] = { 12.01f,12.03f,12.09f };
    int sz = sizeof(arr) / sizeof(arr[0]);//计算数组长度
    qsort(arr, sz, sizeof(float), cmp_float);
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%f  ", arr[i]);//输出结果为12.010000  12.030000  12.090000
    }
    return 0;
}

5.结构体类型排序

#include <stdio.h>
#include <stdlib.h>
struct stu
{
    char name[20];
    int age;
};
int cmp_s_age(const void* e1, const void* e2)//比较结构体中int类型
{
    return ((struct stu*)e1)->age - ((struct stu*)e2)->age;
}
int cmp_s_name(const void* e1, const void* e2)//比较结构体中char类型的数组
{
    return strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name);
}
int main()
{
    struct stu s[] = { {"zhangsan",21} ,{"lisi",20},{"wangwu",52}};
    int i = 0;
    int sz = sizeof(s) / sizeof(s[0]);
    for (i = 0; i < sz; i++)
    {
        printf("%s %d\n", s[i].name, s[i].age);
    }
    qsort(s, sz, sizeof(struct stu), cmp_s_age);//比较年龄，即比较int类型
    //qsort(s, sz, sizeof(struct stu), cmp_s_name);//比较姓名，即比较char类型的数组
    printf("\n");
    for (i = 0; i < sz; i++)
    {
        printf("%s %d\n", s[i].name, s[i].age);//输出为年龄按照升序排列，如果比较姓名，则按照姓名的首字符的ASCII值按照升序排列
    }
    return 0;
}

三、冒泡排序实现qsort函数的功能

1.冒泡排序简介

冒泡排序是通过对两个相邻元素进行比较，如果不符合条件就相互交换位置，并与后面相邻的元素再次比较，直至满足条件为止。

对于冒泡排序，如果它有n个元素，它将进行n-1次的循环。冒泡排序的缺点是只能对整型数组进行排序。

我们通过对整型数组排序进一步了解冒泡排序

//用冒泡排序对整型数组进行排序
#include <stdio.h>
int main()
{
    int i = 0;
    int j = 0;
    int arr[] = { 7,8,9,4,5,6,1,2,3,10 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    for (i = 0; i < sz-1; i++)//总共循环sz-1次
    {
        int flag = 1;//标记，假设数组是有序的
        for (j = 0; j < sz - 1 - i; j++)//第一个元素需要和剩余的sz-1个元素比较，第二个元素需要和sz-1-1个元素比较……所以每次循环需要比较的次数为sz-1-i
        {
            if (arr[j] < arr[j + 1])//从大到小排列
            {
                int tmp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = tmp;
                flag = 0;//倘若发生交换说明数组是无序的
            }
        }
        if(flag == 1)
        {
            break;//如果没发生一次交换说明数组已经是符合要求的有序数组
        }
    }
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);//输出结果为 10 9 8 7 6 5 4 3 2 1
    }
    return 0;
}

2.冒泡排序实现qsort函数功能

对冒泡排序进行qsort化时，要参照qsort函数的参数，尽量做到参数一致。

void qsort_bubble(void* base, int sz, int width, int(*cmp)(const void* e1, const void* e2))

void* base表示对应数组元素的起始位置。

int sz表示数组中元素总个数。

int width表示数组中每个元素所占字节数。

int(*cmp)(const void* e1, const void* e2)是函数指针，指向比较两个元素大小的函数。

设计的冒泡排序qsort化函数qsort_bubble与库函数qsort的参数意义相同。在qsort_bubble和qsort参数中函数指针指向的用于比较数组中两个元素大小的函数不用发生改变，可以直接引用。

利用冒泡排序思想实现qsort函数功能并对结构体排序。

#include <stdio.h>
struct stu
{
	char name[20];
	int age;
};
int cmp_s_age(const void* e1, const void* e2)//比较结构体中整型
{
	return ((struct stu*)e1)->age - ((struct stu*)e2)->age;
}
int cmp_s_name(const void* e1, const void* e2)//比较结构体中整型
{
	return strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name);
}
void Swap(char* buf1, char* buf2, int width)
{
	int i = 0;
	for (i = 0; i < width; i++)//一个字节一个字节的交换
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
void qsort_bubble(void* base, int sz, int width, int(*cmp)(const void* e1, const void* e2))
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width)>0)
				//强制转换成char*类型的指针，进行交换时一个字节一个字节的交换，+width，向后走对应的字节
			{
				Swap((char*)base + j * width, (char*)base + (j + 1) * width,width);//满足条件进行交换
			}
		}
	}
}
int main()
{
	struct stu s[] = { {"zhangsan",21} ,{"lisi",20},{"wangwu",52}};
	int i = 0;
	int sz = sizeof(s) / sizeof(s[0]);
	//printf("%d", sz);
	for (i = 0; i < sz; i++)
	{
		printf("%s %d\n", s[i].name, s[i].age);
	}
	qsort_bubble(s, sz, sizeof(struct stu), cmp_s_age);//比较年龄，即比较int类型
	//qsort_bubble(s, sz, sizeof(struct stu), cmp_s_name);//比较姓名，即比较char类型的数组
	printf("\n");
	for (i = 0; i < sz; i++)
	{
		printf("%s %d\n", s[i].name, s[i].age);
	}
	return 0;
}

到此这篇关于C语言中qsort函数用法及用冒泡排序实现的文章就介绍到这了,更多相关C语言 qsort函数内容请搜索编程学习网以前的文章希望大家以后多多支持编程学习网！

本文标题为：C语言中qsort函数用法及用冒泡排序实现

上一篇： C++ Array容器的显示和隐式实例化详细介绍
下一篇： 超详细VScode调试教程tasks.json和launch.json的设置

基础教程推荐

学习HTML
学习jQuery
学习Laravel
学习CSS3
学习Vue.js
学习Bootstrap5
学习ThinkPHP
学习AJAX
猜你喜欢
最新文章
热门文章
编程基础
热门标签
网站首页 HTML/CSS 菜单 Layui Yii2