使用库函数qsort()以及利用冒泡排序实现库函数qsort()

qsort库函数用的是快速排序，而并非冒泡排序，但我们可以用冒泡排序来实现与其相同的作用

回忆冒泡排序

void print(int arr[],int sz)
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	int arr[] = { 1,2,3,4,5 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz - 1; i++)
	{
		int flag = 1;
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				flag = 0;
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
		if (flag)
			break;
	}
	print(arr,sz);
	return 0;
}

如何使用库函数qsort()

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

来分析qsort函数的参数，第一个代表着接收数组首元素的地址，第二个接收数组元素个数，第三个接收数组元素大小，第四个接收一个函数指针，这个指针指向一个能够实现比较两个元素大小的函数，并且这个函数的参数是const void* , const void* ,返回类型是void

void print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		printf("%d ", arr[i]);
	}
}
int cmp_int(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}
void test1()
{
	int arr[] = { 1,3,5,7,8,9,6,7,3,4,6,5,4 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	print(arr, sz);
}

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

如何利用冒泡排序实现qsort()

首先我们要思考为什么qsort()的第一个和第四个参数类型分别是void * , int (*compar)(const void *,const void *)),因为在传参时可能传各种类型的值，所以不能定死

struct stu
{
	char arr[20];
	int a;
};
void swap(char* buff1, char* buff2, int width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buff1;
		*buff1 = *buff2;
		*buff2 = tmp;
		buff1++;
		buff2++;
	}
}
int com(void* p1, void* p2)
{
	return ((struct stu*)p1)->a - ((struct stu*)p2)->a;
}
void bubble_sort(void*base, size_t num, size_t width, int (*com)(void*, void*))
{
	size_t i = 0;
	for (i = 0; i < num - 1; i++)
	{
		size_t j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			if (com((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}


int main()
{
	struct stu s[] = { {"zhangsan",20},{"lisi",80},{"wangwu",50} };
	int sz = sizeof(s) / sizeof(s[0]);
	bubble_sort(s, sz, sizeof(s[0]), com);
}

由于实现bubble_sort时不知道传入的类型是什么，但我们可以直接将首元素地址base强制类型转化为char类型，让它每次加上jwidth，width是一个元素的大小，所以每次跳过j个元素,传入com()函数即可计算第n和n+1元素的大小,在实现swap函数时，我们把第n和n+1元素地址传入，并且传入元素大小，由于我们不知道元素什么类型，不能强行创建一个对应的临时变量，但我们知道第n与n+1个元素差width个字节，那我们循环width次，每次交换一个字节即可