用手机可以做网站,网站后台账号,网站首页鲁大师,江苏交通建设监理协会网站9. 模拟实现排序函数
这里我们使用冒泡排序算法#xff0c;模拟实现一个排序函数#xff0c;可以排序任意类型的数据。
这段代码可以排序整型数据#xff0c;我们需要在这段代码的基础上进行改进#xff0c;使得它可以排序任意类型的数据。
#define _CRT_SECURE_NO_WARN…9. 模拟实现排序函数
这里我们使用冒泡排序算法模拟实现一个排序函数可以排序任意类型的数据。
这段代码可以排序整型数据我们需要在这段代码的基础上进行改进使得它可以排序任意类型的数据。
#define _CRT_SECURE_NO_WARNINGS 1
#includestdio.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 - 1 - i; j){if (arr[j] arr[j 1]){int temp arr[j];arr[j] arr[j 1];arr[j 1] temp;}}}
}
void print(int arr[], int sz)
{int i 0;for (i 0; i sz; i){printf(%d , arr[i]);}printf(\n);
}
void test1()
{int arr[] { 1,2,3,4,5,6,7,8,9,10 };//升序int sz sizeof(arr) / sizeof(arr[0]);print(arr, sz);//排序前打印bubble_sort(arr,sz);//排序成降序print(arr, sz);//排序后打印}
int main()
{test1();//排序整型数据
} 那么我们要做的就是将bubble_arr里的int arr[]改为指针的形式并且是void*类型这样就可以接收任意类型的数据再将int sz改为size_t类型仅仅有元素个数还不够我们还需要知道一个元素的大小这样可以方便我们访问所以我们加一个size_t size最后我们再加一个比较函数int (*cmp)(const void* e1,const void* e2),这是一个函数指针所以我们需要根据自己的需求写一个比较函数。 e1是一个指针存放了一个要比较的元素的地址 e2是一个指针存放了一个要比较的元素的地址 e1指向的元素e2指向的元素返回0的数字 e1指向的元素e2指向的元素返回0 e1指向的元素e2指向的元素返回0的数字 1.如果我们要比较整型数据我们就写一个cmp_int将const void*强转成int*再解引用然后两个元素进行相减结果作为这个函数的返回值。由于base的类型是void*所以不能进行1-1所以我们再将base的类型强转成char*然后加上j*size就可以进行每个元素的访问了。我们在进行排序的时候需要将元素交换所以写一个交换函数swap将元素的地址和大小传过去就行了。
2.如果我们要比较结构体数据的首字母我们写一个cmp_stu_by_name作为比较函数字符串的比较我们用strcmp返回值是0,0或者0。
#define _CRT_SECURE_NO_WARNINGS 1
#includestdio.h
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;}
}
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 (arr[j] arr[j 1])if(cmp((char*)base j * size, (char*)base (j 1) * size)0){//交换swap((char*)base j * size, (char*)base (j 1) * size, size);}}}
}
int cmp_int(const void*e1, const void*e2)
{return *(int*)e1 - *(int*)e2;
}
void test1()
{int arr[] { 0,1,2,3,4,5,6,7,8,9 };//升序//排序为降序int sz sizeof(arr) / sizeof(arr[0]);print_arr(arr, sz);bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);print_arr(arr, sz);
}
struct Stu
{char name[20];//20int age;//4
};
int cmp_stu_by_age(const void* e1, const void*e2)
{return ((struct Stu*)e1)-age - ((struct Stu*)e2)-age;
}
int cmp_stu_by_name(const void* e1, const void* e2)
{return strcmp(((struct Stu*)e1)-name, ((struct Stu*)e2)-name);
}
void test2()
{struct Stu arr[] { {zhangsan, 20}, {lisi, 30}, {wangwu, 15}};int sz sizeof(arr) / sizeof(arr[0]);//3bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}
int main()
{//整型数据/字符数据/结构体数据...//可以使用qsort函数对数据进行排序//测试bubble_sort排序整型数据test1();//测试bubble_sort排序结构体的数据//test2();return 0;
}
10. 指针和数组笔试题解析
一维数组
int a[] {1,2,3,4};
printf(%d\n,sizeof(a));
数组名的理解 数组名是数组首元素的地址 但是有2个例外 1. sizeof(数组名)这里的数组名表示整个数组sizeof(数组名)计算的是整个数组的大小单位是字节 2. 数组名这里的数组名表示整个数组数组名取出的是数组的地址
所以答案是4*416。
int a[] {1,2,3,4};
printf(%d\n,sizeof(a0));
a并非单独放在sizeof内部也没有所以数组名a是数组首元素的地址a0还是首元素的地址。
只要是地址大小就是4/8,单位是byte。
int a[] {1,2,3,4};
printf(%d\n,sizeof(*a));
a并非单独放在sizeof内部也没有,所以数组名a是数组首元素的地址.*a *(a0) a[0]。
int a[] {1,2,3,4};
printf(%d\n,sizeof(a1));
a并非单独放在sizeof内部也没有所以数组名a是数组首元素的地址,a1就是第二个元素的地址。a1 a[1] 是第2个元素的地址是地址就是4/8个字节。
int a[] {1,2,3,4};
printf(%d\n,sizeof(a[1]));
a[1]就是数组的第二个元素这里计算的就是第二个元素的大小单位是字节 - 4
int a[] {1,2,3,4};
printf(%d\n, sizeof(a));
a - 是取出数组的地址但是数组的地址也是地址是地址就是4/8个Byte。
数组的地址 和 数组首元素的地址 的本质区别是类型的区别并非大小的区别 a -- int* int * p a; a -- int (*)[4] int (*p)[4] a;
int a[] { 1,2,3,4 };
printf(%d\n, sizeof(*a));对数组指针解引用访问一个数组的大小单位是字节。
sizeof(*a) --- sizeof(a) //16
int a[] { 1,2,3,4 };
printf(%d\n, sizeof(a 1));
a数组的地址a1还是地址是地址就是4/8个字节。
int a[] { 1,2,3,4 };
printf(%d\n, sizeof(a[0]));a[0]是首元素的地址 计算的是地址的大小 4/8 个字节。
int a[] { 1,2,3,4 };
printf(%d\n, sizeof(a[0] 1));
/a[0]是首元素的地址a[0]1就是第二个元素的地址大小4/8个字节。
字符数组
char arr[] { a,b,c,d,e,f };
printf(%d\n, strlen(arr));随机值arr是首元素的地址.
char arr[] { a,b,c,d,e,f };
printf(%d\n, strlen(arr 0));
随机值arr是首元素的地址, arr0还是首元素的地址。
char arr[] { a,b,c,d,e,f };
printf(%d\n, strlen(*arr));
err发生错误arr是首元素的地址, *arr就是首元素 - a - 97。 站在strlen的角度认为传参进去的a-97就是地址97作为地址直接进行访问就是非法访问。
char arr[] { a,b,c,d,e,f };
printf(%d\n, strlen(arr[1]));
err, b - 98。
char arr[] { a,b,c,d,e,f };
printf(%d\n, strlen(arr));
随机值 arr -- char (*)[6] const char*。
char arr[] { a,b,c,d,e,f };
printf(%d\n, strlen(arr 1));
随机值。
char arr[] { a,b,c,d,e,f };
printf(%d\n, strlen(arr[0] 1));
随机值。 char arr[] { a,b,c,d,e,f };printf(%d\n, sizeof(arr));
6数组名arr单独放在sizeof内部计算的是整个数组的大小单位是字节。
char arr[] { a,b,c,d,e,f };
printf(%d\n, sizeof(arr 0));
arr是首元素的地址arr[0]是地址就是4/8个字节。 char* 指针变量的大小和类型无关不管什么类型的指针变量大小都是4/8个字节。 指针变量是用来存放地址的地址存放需要多大空间指针变量的大小就是几个字节。 32位环境下地址是32个二进制位需要4个字节所以指针变量的大小就是4个字节。 64位环境下地址是64个二进制位需要8个字节所以指针变量的大小就是8个字节。 不要在门缝里看指针把指针给看扁了。 char arr[] { a,b,c,d,e,f };printf(%d\n, sizeof(*arr));
arr是首元素的地址*arr就是首元素大小就是1Byte。 char arr[] { a,b,c,d,e,f };printf(%d\n, sizeof(arr[1]))
1. char arr[] { a,b,c,d,e,f };printf(%d\n, sizeof(arr));
arr是数组的地址sizeof(arr)就是4/8个字节。 char arr[] { a,b,c,d,e,f };printf(%d\n, sizeof(arr 1));
arr1 是跳过数组后的地址是地址就是4/8个字节。 char arr[] { a,b,c,d,e,f };printf(%d\n, sizeof(arr[0] 1));
第二个元素的地址是地址就是4/8Byte。 char arr[] abcdef;printf(%d\n, sizeof(arr));
这个字符串创建的时候末尾必定有一个\0所以答案是7. char arr[] abcdef;printf(%d\n, sizeof(arr 0));
arr0就是第一个元素地址就是4/8。 char arr[] abcdef;printf(%d\n, sizeof(*arr)); arr既没有单独放到sizeof内部也没有所以是首元素地址就是a的地址*arr就是取出a的地址大小就是一个字节。 char arr[] abcdef;printf(%d\n, sizeof(arr[1]));arr[1]就是第二个元素的地址所以是1. char arr[] abcdef;printf(%d\n, sizeof(arr));
arr就是取出数组的地址是地址就是4/8个字节。 char arr[] abcdef;printf(%d\n, sizeof(arr 1));
arr1就是跳过整个数组但也是地址就是4/8个字节。 char arr[] abcdef;printf(%d\n, sizeof(arr[0] 1));
arr[0]就是取出第一个元素的地址1就是第二个元素的地址就是4/8个字节。 char arr[] abcdef;printf(%d\n, strlen(arr));
这个数组名虽然是单独放在strlen内部但是和sizeof是有区别的所以代表的是首元素地址就是a的地址统计的是\0之前的字符就是6. char arr[] abcdef;printf(%d\n, strlen(arr 0));
arr0代表的是首元素的地址也是6. char arr[] abcdef;printf(%d\n, strlen(*arr));
对首元素的地址进行解引用就是aASCLL值是97所以会报错。 char arr[] abcdef;printf(%d\n, strlen(arr[1]));
arr[1]是第二个元素也会报错。 char arr[] abcdef;printf(%d\n, strlen(arr));
取出的是arr的地址所以是6. char arr[] abcdef;printf(%d\n, strlen(arr 1));跳过整个数组把\0也跳过了因为不知道啥时候遇到\0所以是随机值。 char arr[] abcdef;printf(%d\n, strlen(arr[0] 1));
取出的是第二个元素的地址所以是5. char* p abcdef;printf(%d\n, sizeof(p));把a的地址交给了pp是一个指针变量所以sizeof(p)就是4/8. char* p abcdef;printf(%d\n, sizeof(p 1));
char*指针加1就向后跳过一个字节所以p指向了b也是地址所以是4/8. char* p abcdef;printf(%d\n, sizeof(*p));
p是char*的指针所以解引用访问一个字节就是1. char* p abcdef;printf(%d\n, sizeof(p[0]));
p[0]是第一个元素所以也是1. char* p abcdef;printf(%d\n, sizeof(p));
p也是地址地址就是4/8个字节。 char* p abcdef;printf(%d\n, sizeof(p 1));
p1也是地址所以也是4/8个字节。 char* p abcdef;printf(%d\n, sizeof(p[0] 1));p[0]1就是第二个元素的地址地址就是4/8个字节。 char* p abcdef;printf(%d\n, strlen(p));
遇到\0就停止所以是6. char* p abcdef;printf(%d\n, strlen(p 1));
从第二个元素开始所以是5. char* p abcdef;printf(%d\n, strlen(*p));
*p就是a97所以会出错。 char* p abcdef;printf(%d\n, strlen(p[0]));
p[0]就是第一个元素也是97会出错。 char* p abcdef;printf(%d\n, strlen(p));
p拿到的是随机值。 char* p abcdef;printf(%d\n, strlen(p 1));
p1也是随机值。 char* p abcdef;printf(%d\n, strlen(p[0] 1));
p[0]1就是第二个元素的地址所以是5. 今天的分享到这里就结束啦谢谢老铁们的阅读让我们下期再见。
