题目一
练习使用库函数,qsort排序各种类型的数据
题目二
模拟实现qsort在不同情形的实现
题目三
方法一
方法二
方法三
题目四
方法一
题目五
方法一
题目六
方法一
题目七
方法一
题目八
题目九
或者
做错的选择题
qsort
//排序任意类型数据
void qsort(void* base, size_t num, size_t size,
int (*compar)(const void*, const void*));
#include
#include
#include
//比较函数
int compare(const void* e1, const void* e2)
{
//int sum = (*(char*)e1 - *(char*)e2);
return (*(char*)e2 - *(char*)e1);
}
int main()
{
char arr[] = { 'a','g','q','c','c','b','d','e','o','j'};
///*char arr1[5] = "abc";
//char arr2[5] = "zcd";
//char arr3[5] = "dde";
//char arr4[5] = "uef";*/
///*char* arr[4] = { arr1,arr2,arr3,arr4 };*/
int sz = sizeof(arr)/sizeof(arr[0]);
int n = sizeof(arr[0]);
qsort(arr,sz,n,compare);
int i = 0;
for (i = 0;i < sz;i++)
{
printf("%c ", arr[i]);
}
/*printf("%s %s %s %s",arr1,arr2,arr3,arr4);*/
return 0;
}
#include
#include
//定义结构体
struct S
{
char ar1[20];
int age;
int No;
};
//定义一个比较函数
int my_compare(const void* e1, const void* e2)
{
return (*(char*)e1 - *(char*)e2);
}
//交换
void my_sawp(char* p1,char*p2, size_t n)
{
size_t i = 0;
for (i = 0; i < n; i++)
{
char tmp = 0;
tmp = *p1;
*p1 = *p2;
*p2 = tmp;
p1++;
p2++;
}
}
//name的比较函数
int my_compare_name(const void* e1,const void* e2)
{
return strcmp(((struct S*)e1)->ar1, ((struct S*)e2)->ar1);
}
//age的比较函数
int my_compare_age(const void* e1, const void* e2)
{
return ((*(struct S*)e1).age - (*(struct S*)e2).age);
}
//No的比较函数
int my_compare_No(const void* e1, const void* e2)
{
return ((*(struct S*)e1).No - (*(struct S*)e2).No);
}
//模拟的qsort
void my_qsort(void* arr,size_t sz,size_t n,int(*my_compare)(const void*e1,const void*e2))
{
size_t i = 0;
size_t j = 0;
for (i = 0; i < sz; i++)
{
for (j = 0; j < sz - 1; j++)
{
//从小到大,所以用>0
if (my_compare((char*)arr + n * j, (char*)arr + n * (j + 1)) > 0)
{
//达到条件交换
my_sawp((char*)arr + n * j, (char*)arr + n * (j + 1),n);
}
}
}
}
int main()
{
//字符数组
//char arr[] = { 'a','g','q','c','c','b','d','e','o','j' };
//int sz = sizeof(arr) / sizeof(arr[0]);
//int n = sizeof(arr[0]);
//int i = 0;
//
//my_qsort(arr, sz,n,my_compare);
//for (i = 0; i < sz; i++)
//{
// printf("%c ", arr[i]);
//}
//结构体
struct S s1[] = {{ "zhangsan",20,123 }, { "aisi",60,125 }, { "wanwu",70,111 }, { "laoliu",18,106 }};
int sz1 = sizeof(s1) / sizeof(s1[0]);
//my_qsort(s1,sz1,sizeof(s1[0]),my_compare_name);
//my_qsort(s1, sz1, sizeof(s1[0]), my_compare_age);
my_qsort(s1, sz1, sizeof(s1[0]), my_compare_No);
return 0;
}
#include
#include
#include
int my_strlen(const char* arr)
{
assert(arr);
int count = 0;
int i = 0;
for (i = 0; i < 10000; i++)
{
if (*(arr + i) != '\0')
{
count++;
}
else
{
break;
}
}
return count;
}
int main()
{
int n = 0;
char arr[] = "woxinli" ;
//n = strlen(arr);
n = my_strlen(arr);
printf("%d\n", n);
return 0;
}
//计数器方式
int my_strlen(const char * str)
{
int count = 0;
while(*str)
{
count++;
str++;
}
return count;
}
//不能创建临时变量计数器
int my_strlen(const char * str)
{
if(*str == '\0')
return 0;
else
return 1+my_strlen(str+1);
}
//指针-指针的方式
int my_strlen(char *s)
{
char *p = s;
while(*p != ‘\0’ )
p++;
return p-s;
}
#include
#include
void my_strcpy(char* arr2,const char* arr1)
{
int i = 0;
for (i = 0; i < 10000; i++)
{
if (arr1[i] != '\0')
{
arr2[i] = arr1[i];
}
else
{
break;
}
}
}
int main()
{
char arr1[20] = "wojiaoshuaige";
char arr2[20] = { 0 };
//strcpy(arr2,arr1);
my_strcpy(arr2,arr1);
return 0;
}
//1.参数顺序
//2.函数的功能,停止条件
//3.assert
//4.const修饰指针
//5.函数返回值
//6.题目出自《高质量C/C++编程》书籍最后的试题部分
char *my_strcpy(char *dest, const char*src)
{
char *ret = dest;
assert(dest != NULL);
assert(src != NULL);
while((*dest++ = *src++))
{
;
}
return ret;
}
#include
#include
#include
int my_strcmp(const char* arr1, const char* arr2)
{
assert(arr1 && arr2);
int i = 0;
for (i = 0; i < 10000; i++)
{
if (*(arr1 + i) > *(arr2 + i))
{
return 1;
}
else if (*(arr1 + i) < *(arr2 + i))
{
return -1;
}
}
return 0;
}
int main()
{
char arr1[20] = "abcdef";
char arr2[20] = "abcdzf";
/*int n = strcmp(arr1, arr2);*/
int n = my_strcmp(arr1,arr2);
return 0;
}
int my_strcmp (const char * src, const char * dst)
{
int ret = 0 ;
assert(src != NULL);
assert(dest != NULL);
//&&是当ret为0时,加入循环语句中实现++
while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
++src, ++dst;
if ( ret < 0 )
ret = -1 ;
else if ( ret > 0 )
ret = 1 ;
return( ret );
}
#include
#include
#include
void my_strcat(char* arr1,const char* arr2)
{
assert(arr1 && arr2);
int i = 0;
int sz = 0;
sz = strlen(arr1);
for (i = 0; i < 10000; i++)
{
if (arr2[i] != '\0')
{
arr1[sz] = arr2[i];
sz++;
}
else
{
break;
}
}
}
int main()
{
char arr1[20] = "hello ";
char arr2[20] = "bit ";
char arr3[20] = "shaniao";
//strcat(arr1,arr2);
my_strcat(arr1,arr2);
my_strcat(arr1,arr3);
return 0;
}
char *my_strcat(char *dest, const char*src)
{
char *ret = dest;
assert(dest != NULL);
assert(src != NULL);
while(*dest)
{
dest++;
}
while((*dest++ = *src++))
{
;
}
return ret;
}
#include
#include
#include
char* my_strstr(const char* arr1, const char* arr2)
{
assert(arr1 && arr2);
int i = 0;
int j = 0;
int sz = strlen(arr1);
int sz1 = strlen(arr2);
for (i = 0; i < sz; i++)
{
int count = 0;
if (arr1[i] == arr2[0])
{
char* p = &arr1[i];
for (j = 0; j < sz1; j++)
{
if (arr1[i + j] == arr2[j])
{
count++;
}
else if (arr1[i + j] != arr2[j])
{
break;
}
}
if (count == sz1)
{
return p;
}
}
}
return NULL;
}
int main()
{
char arr1[20] = "abcdef";
char arr2[20] = "def";
//char* str = strstr(arr1,arr2);
char* str = my_strstr(arr1, arr2);
return 0;
}
char * strstr (const char * str1, const char * str2)
{
char *cp = (char *) str1;
char *s1, *s2;
if ( !*str2 )
return((char *)str1);
while (*cp)
{
s1 = cp;
s2 = (char *) str2;
while ( *s1 && *s2 && !(*s1-*s2) )
s1++, s2++;
if (!*s2)
return(cp);
cp++;
}
return(NULL);
}
#include
#include
void* my_memcpy(void* s2,const void* s1,size_t n)
{
void* tmp = s2;
while (n--)
{
*((char*)s2) = *((char*)s1);
s2 = (char*)s2 + 1;
s1 = (char*)s1 + 1;
}
return tmp;
}
int main()
{
char arr2[20] = { 0 };
char arr1[20] = "abcdef";
my_memcpy(arr2,arr1,3);
//memcpy(arr2, arr1,3);
return 0;
}
#include
#include
#include
void* my_memmove(void* s1,const void* s2,size_t n)
{
assert(s1 && s2);
void* tmp = s1;
if(s1 >= s2)//当目标地址大于或等于源地址时
{
while (n--)
{
*((char*)s1) = *((char*)s2);
s2 = (char*)s2 + 1;
s1 = (char*)s1 + 1;
}
}
else
while (n--)//当目标地址大于或等于源地址时
{
*((char*)s1+n) = *((char*)s2+n);
}
return tmp;
}
void * memmove ( void * dst, const void * src, size_t count)
{
void * ret = dst;
if (dst <= src || (char *)dst >= ((char *)src + count)) {
/*
* Non-Overlapping Buffers
* copy from lower addresses to higher addresses
*/
while (count--) {
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
}
else {
/*
* Overlapping Buffers
* copy from higher addresses to lower addresses
*/
dst = (char *)dst + count - 1;
src = (char *)src + count - 1;
while (count--) {
*(char *)dst = *(char *)src;
dst = (char *)dst - 1;
src = (char *)src - 1;
}
}
return(ret);
}
关于回调函数描述错误的是( )
A.回调函数就是一个通过函数指针调用的函数
B.回调函数一般通过函数指针实现
C.回调函数一般不是函数的实现方调用,而是在特定的场景下,由另外一方调用。
D.回调函数是调用函数指针指向函数的函数。
调用指针”、“指向函数”是什么鬼……D选项简直逻辑鬼才!ABC就是基础概念,可以复习下。
下面test函数设计正确的是:( )
char* arr[5] = {"hello", "bit"};
test(arr);
A.void test(char* arr);
B.void test(char** arr);
C.void test(char arr[5]);
D.void test(char* arr[5]);
指针的数组传递给子函数变为指针的指针,也就是二级指针。但是允许中括号写法,写成char **arr、char *arr[]、char * arr[5]都可。所以BD正确。
下面程序的结果是:( )
int main() { int aa[2][5] = {10,9,8,7,6,5,4,3,2,1}; int *ptr1 = (int *)(&aa + 1);//&的优先级大于+ int *ptr2 = (int *)(*(aa + 1)); printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1)); return 0; }
A.1, 6
B.10, 5
C.10, 1
D.1, 5
跟上题类似,&aa的类型是int (*)[2][5],加一操作会导致跳转一个int [2][5]的长度,直接跑到刚好越界的位置。减一以后回到最后一个位置1处。*(aa + 1)相当于aa[1],也就是第二行的首地址,自然是5的位置。减一以后由于多维数组空间的连续性,会回到上一行末尾的6处。故选A。
下面代码中print_arr函数参数设计哪个是正确的?( )
int arr[3][5] = {1,2,3,4,5,6,7,8,9,10}; print_arr(arr, 3, 5);
A.void print_arr(int arr[][],int row, int col);
B.void print_arr(int* arr, int row, int col);
C.void print_arr(int (*arr)[5], int row, int col);
D.void print_arr(int (*arr)[3], int row, int col);
二维数组相当于数组的数组,传到子函数变成数组的指针。int arr[3][5]相当于是3个元素的arr,每个元素是int [5],所以int [5]是类型说明不能省略。丢失的信息只有数组的元素个数,也就是3。A丢了类型中的5,B选项指针层级都错了,D选项5写成了3,故选C。
下面程序的结果是:( )
int main() { int a[5] = {5, 4, 3, 2, 1}; int *ptr = (int *)(&a + 1); printf( "%d,%d", *(a + 1), *(ptr - 1)); return 0; }
A.5, 1
B.4, 1
C.4, 2
D.5, 2
*(a + 1)等同于a[1],第一个是4,a的类型是int [5],&a的类型就是int(*)[5],是个数组指针。所以给int(*)[5]类型加一,相当于加了一个int [5]的长度。也就是这个指针直接跳过了a全部的元素,直接指在了刚好越界的位置上,然后转换成了int *后再减一,相当于从那个位置向前走了一个int,从刚好越觉得位置回到了1的地址处,所以第二个是1,故选B。