qsort 函数使用方法详解+模拟实现 qsort 函数

文章目录

  • Ⅰ 函数简介
  • Ⅱ 函数参数
  • Ⅲ 函数的使用方法
    • ⒈compar 的实现
    • ⒉整体代码实现
  • Ⅳ使用冒泡排序模拟实现 qsort 函数
    • ⒈冒泡排序函数本体的实现
    • ⒉整型排序完整代码

Ⅰ 函数简介

  • 按基数对数组的num个元素进行排序,每个元素的长度为字节大小,使用比较函数确定顺序。
  • 此函数使用的排序算法通过调用指定的比较函数来比较元素对,方法是将指向元素对的指针作为参数。
  • 该函数不返回任何值,但通过按compare定义的对其元素进行基本重排序来修改所指向的数组的内容。

Ⅱ 函数参数

void qsort(void* base,
		   size_t num, 
		   size_t width, 
		   int (*compar)(const void* e1, const void* e2));
  • base:待排序的数据的起始位置,为了能够对所有类型的数据进行排序,base 的类型被设置为 void*。

  • num:待排序的数据元素的个数。size_t 为无符号整形。

  • width:待排序的数据元素的大小。

  • compar:函数指针,指向一个比较函数,compar 函数的实现形式需要程序员自己实现。

    • e1:指向需要比较的第一个元素;
    • e2:指向需要比较的第二个元素。

Ⅲ 函数的使用方法

引用头文件

#include 

⒈compar 的实现

int (*compar)(const void* e1, const void* e2)
  • qsort 函数给 cmp 函数规定了特定的参数,设计比较函数的时候参数和返回值都是不能动的。
  • 在函数内部比较 e1、e2 两个值。如果 e1 > e2 则返回正数,e1 = e2 返回 0,e1 < e2 返回负数,qsort 根据比较函数返回的值进行排序进行排序。

确定函数的返回值

  • 将传过来的数据前转为对应的数据类型,然后返回 e1 - e2(或 e2 - e1)的值,即可确定函数返回值的正负性。

1. 比较整型数据

  • 将 e1、e1 两个指针强转为 int*,然后返回这两个指针解引用后的差值。
int cmp_int(const void* e1, const void* e2)
{
	return (*(int*)e1 - *(int*)e2);//返回两个数强转后的差值
}
  • 上述代码是排成升序的,如果想要排成降序,只需要用 e2 - e1 即可

2. 比较浮点型数据

  • 由于函数的返回类型被固定为 int ,所以在返回两个数的差值前还需要将该差值强转为 int。
int cmp_float(const void* e1, const void* e2)
{
	return (int)(*(float*)e1 - *(float*)e2);//需要先将结果强转为 int 再返回
}

3. 比较字符型数据

int cmp_char(const void* e1, const void* e2)
{
	return (int)(*(char*)e1 - *(char*)e2);
}

4. 比较结构体变量

int cmp_by_age(const void*e1, const void*e2)
{
	return (int)(((stu*)e1)->结构体成员 - ((stu*)e2)->结构体成员);
}

5. 比较字符串大小

  • 如果想要比较两个串的大小的话,就得使用 strcmp 函数了。
  • 幸运的是,strcmp 函数逇返回值正好就是 0<、0、>0 这三种。
int cmp_str_size(const void* e1, const void* e2)
{
	return strcmp((char*)e1,(char*)e2);
}

6. 比较其他类型数据

  • 将 e1 和 e2 这两个指针强转为待排序数据对应类型的指针,然后将 e1、e2 指向的值作差。
  • 返回差值前一定要先将差值强转为 int 类型。

⒉整体代码实现

  • 就以最常用的整型数据来举例,其他类型的排序大差不差,无非就是更改 compar 函数的内容罢了。

整型排序

#include 
#include 

int cmp_int(const void* e1, const void* e2)
{
	return (*(int*)e1 - *(int*)e2);//e1 - e2 是排成升序,e2 - e1 是排成降序
}

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

	qsort(arr, sz, sizeof(arr[0]), cmp_int);//需要自己提供比较函数

	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	putchar('\n');

	return 0;
}

浮点型排序

#include 
#include 

int cmp_float(const void* e1, const void* e2)
{
	return (int)(*(float*)e1 - *(float*)e2);//e1 - e2 是排成升序,e2 - e1 是排成降序
}

int main()
{
	float arr[] = { 5.0,4.0,3.0,2.0,1.0 };
	int sz = sizeof(arr) / sizeof(arr[0]);

	qsort(arr, sz, sizeof(arr[0]), cmp_float);//需要自己提供比较函数

	for (int i = 0; i < sz; i++)
	{
		printf("%.1f ", arr[i]);
	}
	putchar('\n');

	return 0;
}

结构体排序

  • 结构体排序就稍微复杂一些了,需要规定排序的成员;
  • 例如:对一堆学生数据排序,每个学生数据有姓名和年龄两个选项,必须选择按照姓名或者年龄这两个中得一个进行排序。
#include 
#include 
#include 

struct S
{
	int age;
	char name[20];
};

int cmp_by_name(const void* e1, const void* e2)//按照姓名排序
{
	return strcmp(((struct S*)e1)->name, ((struct S*)e2)->name);
}

int cmp_by_age(const void* e1, const void* e2)//按照年龄排序
{
	return (((struct S*)e1)->age - ((struct S*)e2)->age);
}

int main()
{
	struct S s[] = { {18,"zhangsan"},{19,"lisi"},{20,"wangwu"}};
	int sz = sizeof(s) / sizeof(s[0]);

	qsort(s, sz, sizeof(s[0]), cmp_by_name);	//按照姓名成员进行排序
	//qsort(s, sz, sizeof(s[0]), cmp_by_age);	//按照年龄成员进行排序

	for (int i = 0; i < sz; i++)
	{
		printf("%d %s\n", s[i].age, s[i].name);
	}

	return 0;
}

Ⅳ使用冒泡排序模拟实现 qsort 函数

  • qsort 函数是基于快速排序的方法实现的;
  • 现在就要使用冒泡排序的方法来模拟实现 qsort 函数。

⒈冒泡排序函数本体的实现

void Swap(char* buf1, char* buf2, int width)
{
	//交换 buf1 和 buf2 指向的元素的向后 width 个字节的内容

	for (int 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 = 0;
	int j = 0;

	for (i = 0; i < sz - 1; i++)
	{
		int flag = 1;

		for (j = 0; j < sz - 1 - i; j++)
		{
			//用比较函数进行比较,不再用 <> 号比较
			//传给 cmp 相当于 base[j] 和 base[j + 1] 的地址;
			//将指针强转为 char*,确保向后访问的最小字节数;
			//然后让 j 或 j + 1 去 * width 确定指针每次 +1 时向后访问 width 个字节

			if (cmp(((char*)base + j * width), (char*)base + (j + 1) * width) > 0)
			{
				//交换

				Swap(((char*)base + j * width), (char*)base + (j + 1) * width, width);
				//传过去这两个元素的起始地址,以及这两个元素的宽度,将这两个元素的每一个字节都进行交换
				flag = 0;
			}
		}

		if (flag)//这一趟没有进行任何交换操作,就没必要继续浪费时间了
		{
			break;
		}
	}
}

⒉整型排序完整代码

  • 这里就只写整型排序的示例了,其他类型数据的排序只需要更改 cmp 函数即可。
#include 

int cmp_int(const void* e1, const void* e2)
{
	return (int)(*(int*)e1 - *(int*)e2);
}

void Swap(char* buf1, char* buf2, int width)
{
	//交换 buf1 和 buf2 指向的元素的向后 width 个字节的内容

	for (int 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 = 0;
	int j = 0;

	for (i = 0; i < sz - 1; i++)
	{
		int flag = 1;

		for (j = 0; j < sz - 1 - i; j++)
		{
			//用比较函数进行比较,不再用 <> 号比较
			//传给 cmp 相当于 base[j] 和 base[j + 1] 的地址;
			//将指针强转为 char*,确保向后访问的最小字节数;
			//然后让 j 或 j + 1 去 * width 确定指针每次 +1 时向后访问 width 个字节

			if (cmp(((char*)base + j * width), (char*)base + (j + 1) * width) > 0)
			{
				//交换,> 0 要排成升序

				Swap(((char*)base + j * width), (char*)base + (j + 1) * width, width);
				//传过去这两个元素的起始地址,以及这两个元素的宽度,将这两个元素的每一个字节都进行交换
				flag = 0;
			}
		}

		if (flag)//这一趟没有进行任何交换操作,就没必要继续浪费时间了
		{
			break;
		}
	}
}

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_int);

	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	putchar('\n');

	return 0;
}

你可能感兴趣的:(#,C语言进阶篇,算法,数据结构,c语言)