C语言学习记录—进阶作业3(函数指针数组、指针和数组运算)

1. 声明一个指向含有10个元素的数组的指针，其中每个元素是一个函数指针，该函数的返回值是int，参数是int* ，正确的是（）

A.(int* p[10])(int*)
B.int[10] * p(int*)
C.int (*(*p)[10])(int*)
D.int((int*)[10]) * p
答案：C - A是数组，B和D错误写法

 

2. 关于回调函数描述错误的是（   ）

A.回调函数就是一个通过函数指针调用的函数
B.回调函数一般通过函数指针实现
C.回调函数一般不是函数的实现方调用，而是在特定的场景下，由另外一方调用。
D.回调函数是调用函数指针指向函数的函数。
答案：D - 语法不通顺
 

3. 字符串旋转结果

写一个函数，判断一个字符串是否为另外一个字符串旋转之后的字符串。
例如：给定s1 = AABCD和s2 = BCDAA，返回1
给定s1 = abcd和s2 = ACBD，返回0.
AABCD左旋一个字符得到ABCDA
AABCD左旋两个字符得到BCDAA
AABCD右旋一个字符得到DAABC

思路一：把arr1的所有可能性都旋转完，且逐一跟arr2比较（穷举法）

int is_left_move(char arr1[], char arr2[])
{
	int len = strlen(arr1);
	int i = 0;
	for (i = 0; i < len; i++)
	{
		char tmp = arr1[0];
		int j = 0;
		for (j = 0; j < len-1; j++)
		{
			arr1[j] = arr1[j + 1];
		}
		arr1[len - 1] = tmp;

		if (strcmp(arr2, arr1) == 0)
			return 1;
	}
	return 0;
}

思路二：arr1自己追加自己，这样里面可以找到所有旋转的可能性。然后看arr2是否是arr1的子串

int is_left_move(char arr1[], char arr2[])
{
	int len1 = strlen(arr1);
	int len2 = strlen(arr2);
    //如果arr2比arr1短，依然可能是arr1的子串，但肯定不是arr1旋转得到的，所以要先判断两个字符串是否相等
    //只有两个字符串长度相等，才考虑旋转可能性
	if (len1 != len2)
		return 0;

	strncat(arr1, arr1, len1);
	if (strstr(arr1, arr2) == NULL)
		return 0;
	else
		return 1;
	//char* ret = strstr(arr1, arr2);
	//if (ret == NULL)
	//	return 0;
	//else
	//	return 1;;
}
int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "cdefab";

	//判断arr2中的字符串是否可以通过arr1中的字符串旋转得到
	int ret = is_left_move(arr1, arr2);
	if (ret == 1)
		printf("OK\n");
	else
		printf("NO\n");

	return 0;
}

4. 下面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]);
答案：BD - 数组名传参，数组名相当于首元素地址，首元素是char*类型，char*的地址是char**，所以B选项正确；D选项是数组形式的形参。

5.下面程序的结果是：（ ）

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
答案：A - &aa取出数组地址，+1跳过整个数组，强制转换为int*，-1就是数组数最后一个元素
         aa是数组首元素地址，二维数组首元素是第一行，+1跳过一行，强制转换为int*，-1就是第一行最后一个元素

6. 下面代码中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);
答案：C - arr是数组名，数组名是首元素地址，二维数组首元素地址是第一行的地址

7.下面程序的结果是：（ ）

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
答案：B - &a取出数组地址，+1跳过数组，强制转换为int*，-1即数组最后一个元素
         a数数组名，数组名是首元素地址，+1跳过一个元素

8. 矩阵转置

KiKi有一个矩阵，他想知道转置后的矩阵（将矩阵的行列互换得到的新矩阵称为转置矩阵），请编程帮他解答。
输入描述：
第一行包含两个整数n和m，表示一个矩阵包含n行m列，用空格分隔。(1≤n≤10, 1≤m≤10)
从2到n + 1行，每行输入m个整数（范围 - 231~231 - 1），用空格分隔，共输入n * m个数，表示第一个矩阵中的元素。
输出描述：输出m行n列，为矩阵转置后的结果。每个数后面有一个空格。
输入：2 3
     1 2 3
     4 5 6
输出：
1 4
2 5
3 6

自己的方法：转置后，元素的横纵坐标互换，例如元素2的坐标由01变为10
老师方法思路：控制行的变量和控制列的变量互换
 

int main() {
    int r = 0;
    int c = 0;
    scanf("%d %d", &r, &c);
    //int arr[r][c];//C99变长数组
    int arr[10][10] = { 0 };
    int i = 0;
    int j = 0;
    for (i = 0; i < r; i++) {
        for (j = 0; j < c; j++) {
            scanf("%d ", &arr[i][j]);
        }
    }

    for (i = 0; i < c; i++) {
        for (j = 0; j < r; j++) {
            printf("%d ", arr[j][i]);
        }
        printf("\n");
    }

    return 0;
}

9. 上三角矩阵判定

上三角矩阵即主对角线以下的元素都为0的矩阵，主对角线为从矩阵的左上角至右下角的连线。
输入描述：第一行包含一个整数n，表示一个方阵包含n行n列，用空格分隔。(1≤n≤10)
从2到n + 1行，每行输入n个整数（范围 - 231~231 - 1），用空格分隔，共输入n * n个数。
输出描述：一行，如果输入方阵是上三角矩阵输出"YES"并换行，否则输出"NO"并换行。
自己的方法：遍历三角矩阵，利用变量监视，如果有不等于0就终止循环并输出NO

int main() {
    int n = 0;
    scanf("%d ", &n);

    //int arr[n][n];//C99变长数组
    int arr[10][10];
    int i = 0;
    int j = 0;
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            scanf("%d ", &arr[i][j]);
        }
    }

    //方法一：
    int flag = 1;//表示是上三角矩阵
    for (i = 1; i < n; i++) {
        for (j = 0; j < i; j++) {
            if (arr[i][j] != 0) {
                flag = 0;
                break;
            }
        }
        if (flag == 0) {
            printf("NO\n");
            break;
        }
    }
    if (flag == 1)
        printf("YES\n");

    //方法二：
    int flag = 1;
    for (i = 1; i < n && flag == 1; i++) {
        for (j = 0; j < i; j++) {
            if (arr[i][j] != 0) {
                flag = 0;
                goto end;
            }
        }
    }
end:
    if (flag == 1)
        printf("YES\n");
    else
        printf("NO\n");

    //方法三：上三角矩阵加起来等于0就是，不等于0就不是
    return 0;
}

10. 有序序列判断

输入一个整数序列，判断是否是有序序列，有序，指序列中的整数从小到大排序或者从大到小排序(相同元素也视为有序)
输入描述：
第一行输入一个整数N(3≤N≤50)。
第二行输入N个整数，用空格分隔N个整数。
输出描述：输出为一行，如果序列有序输出sorted，否则输出unsorted。

思路：
使用两个flag，flag1监视升序，flag2监视降序。
初始化flag1和flag2为0。
如果后一个数比前一个数大，flag1置为1；如果后一个数比前一个数小，flag2置为1。
最后如果flag1+flag2等于1说明有序
 

#include <math.h>
#include <stdio.h>
int main() {
    int n = 0;
    scanf("%d", &n);

    int i = 0;
    int arr[n];
    int flag1 = 0;
    int flag2 = 0;
    for (i = 0; i < n; i++) {
        scanf("%d ", &arr[i]);
        if (i > 0) {//读取到第一个元素时(即下标为0)还不能比较，所以要读取到第二个元素时才能比较，即下标要大于0
            if (arr[i] > arr[i - 1])
                flag1 = 1;
            else if (arr[i] < arr[i - 1])
                flag2 = 1;
            else
                ;
        }
    }
    if (flag1 + flag2 <= 1)//全相等也是有序，但flag1和flag2还是0，所以判断条件是小于等于1
        printf("sorted\n");
    else
        printf("unsorted\n");

}