qsort的理解--加强对指针的理解

前言：前面我们学习指针变量，数组指针变量，函数指针变量；这些实际上都是变量，实质上是在内存中开辟一块空间；而这些变量存储的都是地址。还有指针数组，函数指针数组，这指的是把多个地址存在数组中，要注意分别。

---

回调函数

在将qort之前，先来引入一个回调函数的概念。

回调函数就是一个通过函数指针调用的函数。

如果你把函数指针(地址)作为参数传给另一个函数，当这个指针被用来调用其所指向的函数，这就是回调函数。

 

---

 冒泡排序

冒泡排序的核心思想就是：俩俩相邻的元素进行比较。

---

问题与解答(递进式解决)

1. 问题：如果我们有10个元素，要进行几次排序？

回答：首先，进行第一次排序，把最大的一个数字排在最右边，然后就不用再和别的数字进行比较。最后一个数字不用比较，直接固定。所以要进行9次排序

 

---

2.问题：那10个元素需要比较几次？

 回答：对于第一次排序，有10个元素，需要进行9对比较；第二次，最大数字固定好了，就9个元素，进行8对比较，依次类推。

---

 

#include <stdio.h>
void bubble_sort(int arr[], int sz) //参数接收的元素的个数
{
	int i = 0;
	int j = 0;
	for (i = 0; i < sz - 1; i++) //循环n-1次
	{
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int bottle = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = bottle;
			}
		}
	}
}
void print_sort(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}


}

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

	return 0;
}

 

---

 

qsort函数使用

qsort--库函数，它可以实现任意类型数据的排序。它用是快速排序。 默认升序

qsort函数底层使用了回调函数的方式 。

1. 今天学习qsort的使用
2. qsort函数的实现原理，模拟实现一下(冒泡排序的思想)。

先来看一下语法：

 

 void qsort(void* base, //base中存放的是待排序数组的第一个元素的地址

 size_t num, //num存放的是base指向的数组中的元素个数

 size_t size, //size是base指向的数组中一个元素的长度，单位是字节

 int (*compar)(const void*e1, const void*e2) //函数指针-指向了一个比较函数，这个比较函数是用来比较数组中的两个元素的

如果e1指向的元素大于e2指向的元素，那么函数返回>0的数字

如果e1指向的元素等于e2指向的元素，那么函数返回0

如果e1指向的元素小于e2指向的元素，那么函数返回<0的数字

 );

---

 qsort对整型的排序

#include <stdio.h>
#include <stdlib.h>

Print(int* p, int len)
{
	int i = 0;
	for (i = 0; i < len; i++)
	{
		printf("%d ", *(p + i));
		

	}
}

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

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

---

 qsort对结构体的排序

struct Stu
{
	char name[200];
	int age;
};

int cmp_stu_by_name(const void* e1, const void* e2)
{
	return strcmp((*(struct Stu*)e1).name, (*(struct Stu*)e2).name);
}

int main()
{

	struct Stu s[3] = { {"zhangsan", 25 }, {"lisi", 98 }, {"wangwu", 11 } };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
	return 0;
}

 

---

  如图，我们可以知道qort默认排序是升序，只需要写一个比较函数，它就能给出排序的结果。

---

 qsort函数的实现原理，模拟实现一下(冒泡排序的思想)。

int main()
{
	test();
	return 0;
}

 通过函数调用实现复杂的逻辑

void test()
{
	int arr[] = { 3,2,6,5,8,4,10,9,7 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), compare);
	Print(arr, sz);
}

 

void bubble_sort(void* base, size_t sz, size_t size, int (*pf)(const void* e1, const void* e2))
{
	int i = 0;
	int j = 0;
	for (i = 0; i < sz - 1; i++)
	{
		for (j = 0; j < sz - i - 1; j++)
		{
			//arr[j] > arr[j + 1];
			if (pf((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

 首先，参数是void，因为不知道传过来的参数是什么，所以用void接收。接下来，把传过来的数据强制类型转换成为字符指针类型，这样每个字节的内容都不会遗漏。

当进入pf函数的时候，就会指向比较函数，这就是回调函数。

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

当符合判断条件的时候，就会进行字节交换。

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

---

 接下来，看一下整体的代码。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void swap(char* p, char* p2, size_t size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *p;
		*p = *p2;
		*p2 = tmp;
		p++;
		p2++;
	}
}

void bubble_sort(void* base, size_t sz, size_t size, int (*pf)(const void* e1, const void* e2))
{
	int i = 0;
	int j = 0;
	for (i = 0; i < sz - 1; i++)
	{
		for (j = 0; j < sz - i - 1; j++)
		{
			//arr[j] > arr[j + 1];
			if (pf((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

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

void test()
{
	int arr[] = { 3,2,6,5,8,4,10,9,7 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), compare);
	Print(arr, sz);
}

int main()
{
	test();
	return 0;
}

---

 

希望对你有帮助，喜欢的点个赞 。