同学们还记得之前我们已经学过一种排序方法叫“冒泡排序“嘛。代码直接附上咯
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 tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
}
int main()
{
int arr[] = { 6,4,1,2,9,3,7,8,10,5 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr,sz);
//打印
for (int i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
现在我们已经找到了一些相应的问题,那我们怎么改造呢?
我们先参考学习一下库函数qsort或许你就会有自己的思路了,qsort的头文件<stdlib.h>
已经了解qsort需要包含的元素,那函数指针指向的比较函数我们要怎么去写呢,这边Mr.狠人举个例子哈
当然这样写是为了让你更好理解,如果能理解的话那我们可以简化代码
//自定义比较函数
int compar(const void* e1,const void* e2)
{
return *(int*)e1 - *(int*)e2;
}
int main()
{
int arr[10] = { 3,1,9,8,5,4,0,2,7,6 };
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), compar);
//打印
for (int i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
当然我们也可以测试一下结构体数据能不能用qsort来排序
//创建一个结构体
struct students
{
char name[20];
int age;
};
//比较函数
int compar_students_by_age(const void* e1, const void* e2)
{
return (*(struct students*)e1).age - (*(struct students*)e2).age;
}
int main()
{
//为了方便理解我们就不演示回调函数,大家使用回调函数肯定更好
struct students classA[3] = { {"jason",18},{"jack",28},{"leon",33} };
int sz = sizeof(classA) / sizeof(classA[0]);
qsort(classA, sz, sizeof(classA[0]), compar_students_by_age);
//打印
for (int i = 0; i < sz; i++)
{
printf("%d %s\n", classA[i].age,classA[i].name);
}
return 0;
}
当然我们也可以不按照age来比,我们用name来比,字符串的比较方式用strcmp函数比较
//创建一个结构体
struct students
{
char name[20];
int age;
};
//比较函数
//字符串的比较不能直接用大于号小于号
int compar_students_by_name(const void* e1, const void* e2)
{
return strcmp((*(struct students*)e1).name,(*(struct students*)e2).name);
}
int main()
{
struct students classA[3] = { {"jason",18},{"jack",28},{"leon",33} };
int sz = sizeof(classA) / sizeof(classA[0]);
qsort(classA, sz, sizeof(classA[0]), compar_students_by_name);
//打印
for (int i = 0; i < sz; i++)
{
printf("%d %s\n", classA[i].age,classA[i].name);
}
return 0;
}
现在我们已经学会了qsort的使用方法,那么有没有思路去改造我们的冒泡排序了?还是把这张图拿下来哈
我们参考过qsort,我们是不是可以跟他一样用void*指针去接收所有类型的变量的地址
接下来是不是就要解决比较的问题,我们不知道使用者会传来的是什么类型的数组,可能是结构体对吧,那就不难单纯的用大于号小于号去比较
那现在我们的冒泡排序的参数是不是就变成这样了
void bubble_sort(void* base, int sz, int width, int(*compar)(const void* e1, const void* e2))
比较函数的调用就是这样
int i = 0;//趟数
for (i = 0; i < sz - 1; i++)
{
int j = 0;
for (j = 0; j < sz - i - 1; j++)
{
//我们在这边已经有宽度了,那是不是全用char类型就行,因为char类型是一个字节,乘宽度刚好是我们需要的大小
if(compar((char*)base+j*width, (char*)base + (j+1) * width)>0)//调用比较函数
{
//交换
}
}
}
现在就剩下交换了
那我们写个函数进行元素交换吧
Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
//交换函数
//调用时就已经强制转换成char*,所以这边直接写char*就行
void Swap(char* buf1, char* buf2, int width)
{
for (int i = 0; i < width; i++)
{
char tmp = *buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}
要改的三个点我们都解决了,整理一下升级后的代码吧
//自定义比较函数(int)
int compar_int(const void* e1,const void* e2)
{
return *(int*)e1 - *(int*)e2;
}
//交换函数
void Swap(char* buf1, char* buf2, size_t width)
{
for (int i = 0; i < width; i++)
{
char tmp = *buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}
//冒泡排序函数
void bubble_sort(void* base, size_t sz, size_t width, int(*compar)(const void* e1, const void* e2))
{
int i = 0;//趟数
for (i = 0; i < sz - 1; i++)
{
int j = 0;
for (j = 0; j < sz - i - 1; j++)
{
if(compar((char*)base+j*width, (char*)base + (j+1) * width)>0)
{
Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
}
}
}
}
//test函数
void test()
{
int arr[] = { 6,4,1,2,9,3,7,8,10,5 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sz, sizeof(arr[0]), compar_int);
//打印
for (int i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
int main()
{
test();
return 0;
}
//创建一个结构体
struct students
{
char name[20];
int age;
};
//比较函数(结构体name)
int compar_students_by_name(const void* e1, const void* e2)
{
return strcmp((*(struct students*)e1).name,(*(struct students*)e2).name);
}
//自定义比较函数(int)
int compar_int(const void* e1,const void* e2)
{
return *(int*)e1 - *(int*)e2;
}
//交换函数
void Swap(char* buf1, char* buf2, size_t width)
{
for (int i = 0; i < width; i++)
{
char tmp = *buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}
//冒泡排序函数
void bubble_sort(void* base, size_t sz, size_t width, int(*compar)(const void* e1, const void* e2))
{
int i = 0;//趟数
for (i = 0; i < sz - 1; i++)
{
int j = 0;
for (j = 0; j < sz - i - 1; j++)
{
if(compar((char*)base+j*width, (char*)base + (j+1) * width)>0)
{
Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
}
}
}
}
//test函数
void test()
{
struct students classA[3] = { {"jason",18},{"jack",28},{"leon",33} };
int sz = sizeof(classA) / sizeof(classA[0]);
bubble_sort(classA, sz, sizeof(classA[0]), compar_students_by_name);
//打印
for (int i = 0; i < sz; i++)
{
printf("%s %d ", classA[i].name,classA[i].age);
}
}
int main()
{
test();
return 0;
}
这样我们的代码也就写完了,通过这一次的改写冒泡排序,我们是不是能感受到void*指针的遍历,这种编程叫做泛型编程。
大家可以在自行梳理一下,有帮助请给一个三连吧!
标签:sz,arr,int,void,qsort,C语言,char,width,模拟 From: https://blog.csdn.net/CPP_ZhouXuyang/article/details/141895294