【qsort使用与模拟实现】

qsort函数的使用

对任意类型数组元素进行排序

qsort的调用

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

1. void* base 指针，指向待排序数组第一个元素
2. size_t num base指向待排序数组元素个数
3. size_t size base指向待排序数组元素大小
4. int (* compar)(const void*,const void*) 函数指针，指向的就是两个元素比较的函数
   

使用qsort函数排序整形数据

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

int main()
{
	int arr[] = { 1,3,5,7,9,2,4,6,8,10 };
	qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), arr_sort);
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
		printf("%d ", arr[i]);
	}

	return 0;
}

使用qsort函数排序结构数据

创建结构体

struct Stu//学生
{
	char name[20];//名字
	int age;//年龄
};

按照年龄来比较

int str_sort_age(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}
int main()
{
	struct Stu s[] = { {"zhangsan",20}, {"lisi",18},{"wangwu",21} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), str_sort_age);
	for (int i = 0; i < sz; i++)
	{
		printf("%s %d\n", s[i].name, s[i].age);
	}
	return 0;
}

按照名字来比较

int str_sort_name(const void* p1, const void* p2)
{
	return strcmp(((struct Stu*)p1)->name , ((struct Stu*)p2)->name);
	//strcmp - 是库函数，专门用来比较两个字符串大小，需包含头文件<string.h>
}
int main()
{
	struct Stu s[] = { {"zhangsan",20}, {"lisi",18},{"wangwu",21} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), str_sort_name);
	for (int i = 0; i < sz; i++)
	{
		printf("%s %d\n", s[i].name, s[i].age);
	}
	return 0;
}

qsort函数的模拟实现

主函数与模拟函数

按照qsort的调用方式，写出模拟函数“bublle”

bubble_sort(arr, sz,sizeof(int),int_cmp);

往模拟函数中1.传入数组首元素地址 2.数组长度 3.数组元素大小 4.比较大小的函数

所以主函数就可以写出

int main()
{
	int arr[] = { 3,1,7,58,9,4,6,2 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz,sizeof(int),int_cmp);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

冒泡排序思想实现模拟函数

冒泡排序

两两相邻元素进行比较

void bubble(int arr[], int sz)
{
	for (int i = 0; i < sz - 1; i++) //排序趟数
	{
		for (int j = 0; j < sz - i - 1; j++) {
			if (arr[j] > arr[j + 1]) {
				int t = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = t;
			}
		}
	}
}

int main()
{
	int arr[] = { 3,1,7,58,9,4,6,2 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble(arr, sz);
	for (int i = 0; i < sz; i++) {
		printf("%d", arr[i]);
	}
	return 0;
}

利用冒泡排序函数改成qsort模拟函数

冒泡排序中主函数除了更改调用函数，需要思考模拟函数中if里面的条件以及如何交换

void bubble_sort(void* base,int count,int size,int(*cmp)(void*,void*))
{
	for (int i = 0; i < count - 1; i++)
	{
		for (int j = 0; j < count - i - 1; j++)
		{
			if(？？？){

	           swap(？？？);

			}
		}
	}
}

Q：

1. 如何判断大小？
2. 如何交换？

A：
1.int(* cmp)(void * ,void*)
传函数指针给qsort的目的就是为了比较待排序数组元素大小
用户传了一个数组给我们的函数进行排序，可是我们不知道用户穿的是什么类型的数组
但是用户将待排序数组的首元素地址、元素大小告诉了我们的函数
我们就可以将首元素强制类型转换成最小字节char类型**（char*）base**
再加上一个元素大小、就可以跳过一个类型、实现两两相邻元素进行比较

if(cmp((char*)base + j * size , (char*)base + (j+1) * size)>0)
{
    swap(???);

}

2.到了交换这一步，我们则必须要写一个交换的函数就可以了

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

原理与第一步相同。

qsort模拟函数

就可以实现排序了

void swap(void* p1, void* p2,int size)
{
	for (int i = 0; i < size; i++)
	{
		char t = *((char*)p1 + i);
		*((char*)p1 + i) = *((char*)p2 + i);
		*((char*)p2 + i) = t;
	}
}
void bubble_sort(void* base,int count,int size,int(*cmp)(void*,void*))
{
	for (int i = 0; i < count - 1; i++)
	{
		for (int 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);
			}
		}
	}
}

模拟用户使用我们的qsort模拟函数

int int_cmp(const void* p1, const void* p2)//用户创建的函数
{
	return *(int*)p1 - *(int*)p2;
}

void swap(void* p1, void* p2,int size)
{
	for (int i = 0; i < size; i++)
	{
		char t = *((char*)p1 + i);
		*((char*)p1 + i) = *((char*)p2 + i);
		*((char*)p2 + i) = t;
	}
}
void bubble_sort(void* base,int count,int size,int(*cmp)(void*,void*))
{
	for (int i = 0; i < count - 1; i++)
	{
		for (int 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[] = { 3,1,7,58,9,4,6,2 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz,sizeof(int),int_cmp);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

本篇完结