进阶C语言-指针的进阶（三）-Toy模板网

这篇具有很好参考价值的文章主要介绍了进阶C语言-指针的进阶（三）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

进阶C语言-指针的进阶（三）,进阶C语言,c语言,排序算法,算法

📝关于qsort函数，我们可以先去cpluplus网站上面了解一下：
进阶C语言-指针的进阶（三）,进阶C语言,c语言,排序算法,算法

//1.排序整型数组，两个整型可以直接使用大于号比较。
//2.排序结构体数组，两个结构体数据可能不能直接使用大于号比较。
//不同类型的数据，比较出大小，方法是有差异的。
void qsort (void* base//待排序数组的第一个元素的地址
,           size_t num//待排序数组的元素个数
,           size_t size//待排序数组中一个元素的大小
,           int (*compar)(const void* e1,const void* e2));//函数指针compar指向了一个函数，这个函数是用来比较两个元素的
//e1和e2中存放的是需要比较的两个元素的地址

🎈1.测试bubble_sort，排序整型数组

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
//目标：使用冒泡排序的算法，模拟实现一个排序函数，可以排列任意类型的数据
void bubble_sort(int arr[],int sz)
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;  
			}
		}
	}
}
void print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
void test1()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };//降序
	//排序为升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	print_arr(arr, sz);
	bubble_sort(arr, sz);
	print_arr(arr, sz);
}
int main()
{
	//整型数据/字符数据/结构体数据...
	//可以使用qsort函数进行排序
	//测试bubble_sort，排序整型数组
	test1();
	return 0;
}

✅运行示例：
进阶C语言-指针的进阶（三）,进阶C语言,c语言,排序算法,算法

🔎我们发现上述代码只适用于整型数据，那么我们是否能写出更一般的更普遍的代码呢？

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
//目标：使用冒泡排序的算法，模拟实现一个排序函数，可以排列任意类型的数据
void print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
//int (*cmp)(const void* e1, const void* e2)
//e1是一个指针，存放了一个要比较的元素的地址
//e2也是一个指针，存放了一个要比较的元素的地址
//e1指向的元素>e2指向的元素，返回>0的数字
//e1指向的元素==e2指向的元素，返回0
//e1指向的元素<e2指向的元素，返回<0的数字
void swap(char* buf1, char* buf2, size_t size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
int cmp_int(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}
void bubble_sort(void* base, size_t num, size_t size, int(*cmp)(const void* e1, const void* e2))
{
	//冒泡排序的趟数
	int i = 0;
	for (i = 0; i < num - 1; i++)
	{
		//一趟冒泡排序
		int j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				//交换
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}

	}
}
void test1()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };//降序
	//排序为升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	print_arr(arr, sz);
	bubble_sort(arr, sz,sizeof(arr[0]),cmp_int);
	print_arr(arr, sz);
}
int main()
{
	//整型数据/字符数据/结构体数据...
	//可以使用qsort函数进行排序
	//测试bubble_sort，排序整型数组
	test1();
	return 0;
}

✅运行示例：
进阶C语言-指针的进阶（三）,进阶C语言,c语言,排序算法,算法
📖运行流程如下：

🎈2测试bubble_sort，排序结构体数组

🔎按照年龄排序：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
//目标：使用冒泡排序的算法，模拟实现一个排序函数，可以排列任意类型的数据
struct Stu
{
	char name[20];
	int age;
};
//int (*cmp)(const void* e1, const void* e2)
//e1是一个指针，存放了一个要比较的元素的地址
//e2也是一个指针，存放了一个要比较的元素的地址
//e1指向的元素>e2指向的元素，返回>0的数字
//e1指向的元素==e2指向的元素，返回0
//e1指向的元素<e2指向的元素，返回<0的数字
void swap(char* buf1, char* buf2, size_t size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
int cmp_stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
void bubble_sort(void* base, size_t num, size_t size, int(*cmp)(const void* e1, const void* e2))
{
	//冒泡排序的趟数
	int i = 0;
	for (i = 0; i < num - 1; i++)
	{
		//一趟冒泡排序
		int j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				//交换
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}

	}
}
void test2()
{
	struct Stu arr[] = { {"Zhangsan",20},{"lisi",19},{"wangwu",18} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz,sizeof(arr[0]),cmp_stu_by_age); 
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%s %d", arr[i].name, arr[i].age);
		printf("\n");
	}
	printf("\n");
}
int main()
{
	//整型数据/字符数据/结构体数据...
	//可以使用qsort函数进行排序
	//测试bubble_sort，排序整型数组
	test2();
	return 0;
}

✅运行示例：
进阶C语言-指针的进阶（三）,进阶C语言,c语言,排序算法,算法
🔎按照姓名排序：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
//目标：使用冒泡排序的算法，模拟实现一个排序函数，可以排列任意类型的数据
struct Stu
{
	char name[20];
	int age;
};
//int (*cmp)(const void* e1, const void* e2)
//e1是一个指针，存放了一个要比较的元素的地址
//e2也是一个指针，存放了一个要比较的元素的地址
//e1指向的元素>e2指向的元素，返回>0的数字
//e1指向的元素==e2指向的元素，返回0
//e1指向的元素<e2指向的元素，返回<0的数字
void swap(char* buf1, char* buf2, size_t size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
int cmp_stu_by_name(const void* e1, const void* e2)
{//strcmp为字符串比较函数，需要添加头文件#include <string.h>
	return strcmp(((struct Stu*)e1)->name , ((struct Stu*)e2)->name);
}
void bubble_sort(void* base, size_t num, size_t size, int(*cmp)(const void* e1, const void* e2))
{
	//冒泡排序的趟数
	int i = 0;
	for (i = 0; i < num - 1; i++)
	{
		//一趟冒泡排序
		int j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				//交换
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}

	}
}
void test2()
{//一个结构体大小32个字节
	struct Stu arr[] = { {"zhangsan",20},{"lisi",19},{"wangwu",18} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%s %d", arr[i].name, arr[i].age);
		printf("\n");
	}
	printf("\n");
}
int main()
{
	//整型数据/字符数据/结构体数据...
	//可以使用qsort函数进行排序
	//测试bubble_sort，排序整型数组
	test2();
	return 0;
}