高级语言程序设计课程第六次个人作业

高级语言程序设计课程第六次个人作业

这个作业属于哪个课程:https://edu.cnblogs.com/campus/fzu/2026gjyycxsj

这个作业要求在哪里:https://edu.cnblogs.com/campus/fzu/2026gjyycxsj/homework/16752

学号:010100223

姓名:武子腾


作业内容

本次作业共 15 道设计题,围绕指针、数组与函数展开,考察指针传参、数组与指针的关系、二维数组、常用算法(排序/查找/矩阵/质数)等知识点。


(1)按值传递和按地址传递呈现不同效果

代码:

#include <stdio.h>

/* 按值传递:形参是实参的副本,修改形参不影响实参 */
void by_value(int x) {
    x = 100;   /* 只改副本 */
}

/* 按地址传递:形参是指针,通过指针修改实参本身 */
void by_address(int *x) {
    *x = 100;  /* 改指针指向的变量 */
}

int main(void) {
    int a = 10, b = 10;
    printf("调用前:a=%d, b=%d\n", a, b);
    by_value(a);      /* 传值 */
    by_address(&b);   /* 传地址 */
    printf("调用后:a=%d(按值传递,没变), b=%d(按地址传递,变了)\n", a, b);
    return 0;
}

运行结果:

调用前:a=10, b=10
调用后:a=10(按值传递,没变), b=100(按地址传递,变了)

说明: 按值传递时,形参是实参的副本,函数内修改不影响原变量;按地址传递时,形参是指针,通过 *x 直接修改实参本身,所以 b 被改成 100,a 保持 10 不变。


(2)函数 fun 求小于 m 的非素数

代码:

#include <stdio.h>

/* 判断 n 是否为素数,是返回1,否返回0 */
int is_prime(int n) {
    int i;
    if (n < 2) return 0;
    for (i = 2; i * i <= n; i++)
        if (n % i == 0) return 0;
    return 1;
}

/* 将小于 m 的非素数存入 xx 数组,个数由 k 返回 */
void fun(int m, int *k, int xx[]) {
    int i, cnt = 0;
    for (i = 2; i < m; i++)          /* 从 2 到 m-1 */
        if (!is_prime(i))            /* 非素数 */
            xx[cnt++] = i;
    *k = cnt;
}

int main(void) {
    int xx[100], k, i;
    fun(20, &k, xx);
    printf("小于20的非素数共 %d 个:\n", k);
    for (i = 0; i < k; i++)
        printf("%d ", xx[i]);
    printf("\n");
    return 0;
}

运行结果:

小于20的非素数共 10 个:
4 6 8 9 10 12 14 15 16 18

说明: 函数用 int *k 作为传出参数返回非素数的个数,结果存入 xx 数组。先写一个 is_prime 判断素数,再取反即得非素数。注意 1 既不是素数也不是合数,所以从 2 开始遍历。


(3)从第 m 个字符开始复制字符串

代码:

#include <stdio.h>
#include <string.h>

/* 将 src 从第 m 个字符(从1数起)开始的全部字符复制到 dest */
void copy_from(char *dest, const char *src, int m) {
    strcpy(dest, src + m - 1);   /* 第 m 个字符 = src[m-1] */
}

int main(void) {
    char src[] = "Hello World!";
    char dest[80];
    copy_from(dest, src, 7);   /* 从第7个字符 'W' 开始 */
    printf("原字符串:%s\n", src);
    printf("从第7个字符开始复制:%s\n", dest);
    return 0;
}

运行结果:

原字符串:Hello World!
从第7个字符开始复制:World!

说明: 第 m 个字符在数组中的下标是 m-1,所以用 strcpy(dest, src + m - 1) 一步完成复制。


(4)冒泡法将数组从小到大排序

代码:

#include <stdio.h>

/* 冒泡排序:从小到大 */
void bubble_sort(int arr[], int n) {
    int i, j, temp;
    for (i = 0; i < n - 1; i++)
        for (j = 0; j < n - 1 - i; j++)
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
}

int main(void) {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);
    int i;
    printf("排序前:");
    for (i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
    bubble_sort(arr, n);
    printf("排序后:");
    for (i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

运行结果:

排序前:64 34 25 12 22 11 90
排序后:11 12 22 25 34 64 90

说明: 冒泡排序用双层循环:外层控制趟数(n-1 趟),内层相邻两两比较,把较大者往后"冒"。每趟结束最大的元素沉到末尾,内层比较次数逐趟递减。


(5)n 个整数逆序排列(带指针参数的函数)

代码:

#include <stdio.h>

/* 逆序排列:用指针参数原地反转 */
void reverse(int *arr, int n) {
    int *left = arr, *right = arr + n - 1, temp;
    while (left < right) {
        temp = *left;
        *left = *right;
        *right = temp;
        left++;
        right--;
    }
}

int main(void) {
    int arr[] = {1, 2, 3, 4, 5, 6};
    int n = sizeof(arr) / sizeof(arr[0]);
    int i;
    printf("输入顺序:");
    for (i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
    reverse(arr, n);
    printf("逆序排列:");
    for (i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

运行结果:

输入顺序:1 2 3 4 5 6
逆序排列:6 5 4 3 2 1

说明: 用两个指针 left 和 right 分别指向数组首尾,交换后向中间靠拢,直到 left >= right,原地完成逆序,只用了 O(1) 额外空间。


(6)用指针打印数组(不使用下标)

代码:

#include <stdio.h>

/* 用指针打印数组,不使用下标 */
void print_arr(int *arr, int n) {
    int *p;
    for (p = arr; p < arr + n; p++)
        printf("%d ", *p);
    printf("\n");
}

int main(void) {
    int arr[] = {10, 20, 30, 40, 50};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("数组内容(用指针打印):\n");
    print_arr(arr, n);
    return 0;
}

运行结果:

数组内容(用指针打印):
10 20 30 40 50

说明: 指针 p 从 arr 开始,每次 *p 取当前元素,p++ 后移到下一个元素,直到 p == arr + n(越过末尾)。整个过程不出现任何下标。


(7)找出 n×m 数组的最大值、最小值及下标

代码:

#include <stdio.h>
#define M 3
#define N 4

/* 找 n×m 数组的最大值、最小值及下标 */
void find_max_min(int arr[][N], int n, int m,
                  int *max, int *maxi, int *maxj,
                  int *min, int *mini, int *minj) {
    int i, j;
    *max = *min = arr[0][0];
    *maxi = *maxj = *mini = *minj = 0;
    for (i = 0; i < n; i++)
        for (j = 0; j < m; j++) {
            if (arr[i][j] > *max) { *max = arr[i][j]; *maxi = i; *maxj = j; }
            if (arr[i][j] < *min) { *min = arr[i][j]; *mini = i; *minj = j; }
        }
}

int main(void) {
    int arr[M][N] = {{3, 9, 1, 7}, {8, 5, 12, 4}, {6, 2, 11, 10}};
    int max, maxi, maxj, min, mini, minj;
    int i, j;
    find_max_min(arr, M, N, &max, &maxi, &maxj, &min, &mini, &minj);
    printf("数组:\n");
    for (i = 0; i < M; i++) {
        for (j = 0; j < N; j++) printf("%3d ", arr[i][j]);
        printf("\n");
    }
    printf("最大值=%d, 下标[%d][%d]\n", max, maxi, maxj);
    printf("最小值=%d, 下标[%d][%d]\n", min, mini, minj);
    return 0;
}

运行结果:

数组:
  3   9   1   7
  8   5  12   4
  6   2  11  10
最大值=12, 下标[1][2]
最小值=1, 下标[0][2]

说明: 一次遍历同时维护最大值和最小值及其行列下标。二维数组作为函数参数时,第二维(列数)必须写死为常量 N,第一维可以省略。


(8)判断上三角矩阵

代码:

#include <stdio.h>
#define N 4

/* 判断方阵是否为上三角矩阵:主对角线以下全为0 */
int is_upper_triangular(int a[][N], int n) {
    int i, j;
    for (i = 0; i < n; i++)
        for (j = 0; j < i; j++)        /* 主对角线以下的元素 */
            if (a[i][j] != 0) return 0;
    return 1;
}

int main(void) {
    int a[N][N] = {{1, 2, 3, 4}, {0, 5, 6, 7}, {0, 0, 8, 9}, {0, 0, 0, 10}};
    int i, j;
    printf("方阵:\n");
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) printf("%3d ", a[i][j]);
        printf("\n");
    }
    printf(is_upper_triangular(a, N) ? "是上三角矩阵\n" : "不是上三角矩阵\n");
    return 0;
}

运行结果:

方阵:
  1   2   3   4
  0   5   6   7
  0   0   8   9
  0   0   0  10
是上三角矩阵

说明: 上三角矩阵要求主对角线以下(即 j < i 的位置)全为 0。只需遍历下三角区域,发现非 0 立即返回 0。


(9)升序二维数组中查找目标值(快速查询)

代码:

#include <stdio.h>
#define M 3
#define N 4

/* 在每行每列都升序的矩阵中查找目标值,存在返回1 */
int search_matrix(int a[][N], int m, int n, int target) {
    int i = m - 1, j = 0;   /* 从左下角开始 */
    while (i >= 0 && j < n) {
        if (a[i][j] == target) return 1;
        else if (a[i][j] > target) i--;  /* 当前值太大,向上走 */
        else j++;                        /* 当前值太小,向右走 */
    }
    return 0;
}

int main(void) {
    int a[M][N] = {{1, 4, 7, 11}, {2, 5, 8, 12}, {3, 6, 9, 16}};
    int target = 8;
    int i, j;
    printf("矩阵(每行每列升序):\n");
    for (i = 0; i < M; i++) {
        for (j = 0; j < N; j++) printf("%3d ", a[i][j]);
        printf("\n");
    }
    printf("目标值 %d 是否在数组中:%s\n", target,
           search_matrix(a, M, N, target) ? "存在" : "不存在");
    return 0;
}

运行结果:

矩阵(每行每列升序):
  1   4   7  11
  2   5   8  12
  3   6   9  16
目标值 8 是否在数组中:存在

说明: 利用"每行每列都升序"的性质,从左下角出发:当前值大于目标则向上走,小于目标则向右走,时间复杂度 O(m+n),比暴力枚举快得多。


(10)整数分解为两个质数之和

代码:

#include <stdio.h>

int is_prime(int n) {
    int i;
    if (n < 2) return 0;
    for (i = 2; i * i <= n; i++)
        if (n % i == 0) return 0;
    return 1;
}

/* 将 n 分解为两个质数之和,成功返回1,a b 存两个质数 */
int split(int n, int *a, int *b) {
    int i;
    for (i = 2; i <= n / 2; i++)
        if (is_prime(i) && is_prime(n - i)) {
            *a = i;
            *b = n - i;
            return 1;
        }
    return 0;
}

int main(void) {
    int n = 34, a, b;
    if (split(n, &a, &b))
        printf("%d = %d + %d(两个质数之和)\n", n, a, b);
    else
        printf("%d 无法分解为两个质数之和\n", n);
    return 0;
}

运行结果:

34 = 3 + 31(两个质数之和)

说明: 函数声明 int split(int n, int *a, int *b),n 是传入参数,a、b 是传出参数。遍历 i 从 2 到 n/2,若 i 和 n-i 都是质数即成功分解(哥德巴赫猜想保证偶数总能分解)。返回 1 表示成功,0 表示失败。


(11)字符串循环左移 n 次

代码:

#include <stdio.h>
#include <string.h>

/* 反转 [start, end] 区间(含两端)的字符 */
static void reverse_range(char *start, char *end) {
    char temp;
    while (start < end) {
        temp = *start;
        *start = *end;
        *end = temp;
        start++;
        end--;
    }
}

/* 原地将字符串 s 循环左移 n 次(三步反转法) */
void shift(char *s, int n) {
    int len = strlen(s);
    n %= len;                        /* n 超过长度时取余 */
    if (n == 0) return;
    reverse_range(s, s + n - 1);         /* 反转前 n 个 */
    reverse_range(s + n, s + len - 1);   /* 反转剩余 */
    reverse_range(s, s + len - 1);       /* 整体反转 */
}

int main(void) {
    char s[] = "hello";
    printf("原字符串:%s\n", s);
    shift(s, 3);
    printf("左移3次后:%s\n", s);
    return 0;
}

运行结果:

原字符串:hello
左移3次后:lohel

说明: 函数声明 void shift(char *s, int n),原地完成。采用三步反转法:先反转前 n 个字符,再反转剩余部分,最后整体反转。这样只用了 O(1) 额外空间。注意 n 可能超过字符串长度,要先 n %= len 取余。


(12)判断魔方矩阵

代码:

#include <stdio.h>
#define N 3

/* 判断魔方矩阵:所有行、列、对角线和都相等 */
int is_magic(int a[][N], int n) {
    int sum = 0, i, j, s;
    for (j = 0; j < n; j++) sum += a[0][j];   /* 第一行和作为基准 */
    for (i = 0; i < n; i++) {                 /* 每行 */
        s = 0;
        for (j = 0; j < n; j++) s += a[i][j];
        if (s != sum) return 0;
    }
    for (j = 0; j < n; j++) {                 /* 每列 */
        s = 0;
        for (i = 0; i < n; i++) s += a[i][j];
        if (s != sum) return 0;
    }
    s = 0;
    for (i = 0; i < n; i++) s += a[i][i];     /* 主对角线 */
    if (s != sum) return 0;
    s = 0;
    for (i = 0; i < n; i++) s += a[i][n - 1 - i];  /* 副对角线 */
    if (s != sum) return 0;
    return 1;
}

int main(void) {
    int a[N][N] = {{8, 1, 6}, {3, 5, 7}, {4, 9, 2}};  /* 三阶魔方阵 */
    int i, j;
    printf("矩阵:\n");
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) printf("%2d ", a[i][j]);
        printf("\n");
    }
    printf(is_magic(a, N) ? "是魔方矩阵\n" : "不是魔方矩阵\n");
    return 0;
}

运行结果:

矩阵:
 8  1  6
 3  5  7
 4  9  2
是魔方矩阵

说明: 魔方阵要求所有行、列、两条对角线的和都相等。先用第一行的和作为基准,再逐一校验每行、每列、主对角线、副对角线,任何一处不等即返回 0。


(13)忽略大小写判断两个字符串是否相等

代码:

#include <stdio.h>
#include <ctype.h>

/* 忽略大小写比较两个字符串,相等返回1,不同返回0 */
int str_equal_ignore_case(const char *s1, const char *s2) {
    while (*s1 && *s2) {
        if (tolower((unsigned char)*s1) != tolower((unsigned char)*s2))
            return 0;
        s1++;
        s2++;
    }
    return *s1 == *s2;   /* 两个都到末尾才相等 */
}

int main(void) {
    char s1[] = "hello";
    char s2[] = "hELlO";
    printf("\"%s\" 和 \"%s\" 忽略大小写比较:%s\n", s1, s2,
           str_equal_ignore_case(s1, s2) ? "相等" : "不相等");
    return 0;
}

运行结果:

"hello" 和 "hELlO" 忽略大小写比较:相等

说明: 用 tolower 把每个字符转小写再比较,遇到不同立即返回 0。循环结束后,只有两个字符串同时到达末尾(*s1 == *s2 == '\0')才算相等。tolower 需要包含 <ctype.h>,且参数建议转成 unsigned char 避免负值 char 的未定义行为。


(14)按顺序打印数组元素地址

代码:

#include <stdio.h>

int main(void) {
    int a[5] = {1, 2, 3, 4, 5};
    int b[2][3] = {{10, 20, 30}, {40, 50, 60}};
    int i, j;
    printf("一维数组 a[5] 各元素地址:\n");
    for (i = 0; i < 5; i++)
        printf("a[%d] 地址 = %p, 值 = %d\n", i, (void*)&a[i], a[i]);
    printf("\n二维数组 b[2][3] 各元素地址:\n");
    for (i = 0; i < 2; i++)
        for (j = 0; j < 3; j++)
            printf("b[%d][%d] 地址 = %p, 值 = %d\n", i, j, (void*)&b[i][j], b[i][j]);
    return 0;
}

运行结果:

一维数组 a[5] 各元素地址:
a[0] 地址 = 00000086e03ff7d0, 值 = 1
a[1] 地址 = 00000086e03ff7d4, 值 = 2
a[2] 地址 = 00000086e03ff7d8, 值 = 3
a[3] 地址 = 00000086e03ff7dc, 值 = 4
a[4] 地址 = 00000086e03ff7e0, 值 = 5

二维数组 b[2][3] 各元素地址:
b[0][0] 地址 = 00000086e03ff7b0, 值 = 10
...
b[1][2] 地址 = 00000086e03ff7c4, 值 = 60

说明: 用 %p 打印 &a[i] 和 &b[i][j]。可以看到相邻元素地址依次差 4 字节(int 占 4 字节),证明数组元素在内存中是连续存放的。


(15)数组名和指针引用数组元素

代码:

#include <stdio.h>

int main(void) {
    int arr[5] = {10, 20, 30, 40, 50};
    int *p = arr;
    int i;
    printf("用数组名(下标)引用:\n");
    for (i = 0; i < 5; i++)
        printf("arr[%d] = %d\n", i, arr[i]);
    printf("\n用指针(*(p+i) 解引用)引用:\n");
    for (i = 0; i < 5; i++)
        printf("*(p+%d) = %d\n", i, *(p + i));
    printf("\n用指针(p[i] 下标)引用:\n");
    for (i = 0; i < 5; i++)
        printf("p[%d] = %d\n", i, p[i]);
    return 0;
}

运行结果:

用数组名(下标)引用:arr[0]=10 ... arr[4]=50
用指针(*(p+i) 解引用)引用:*(p+0)=10 ... *(p+4)=50
用指针(p[i] 下标)引用:p[0]=10 ... p[4]=50

说明: 数组名 arr 可看作指向首元素的指针常量,p = arr 后,arr[i]、*(p+i)、p[i] 三种写法完全等价,体现了"数组名和指针"的紧密关系。


编写过程中遇到的问题及解决

  1. 非素数的边界:1 既不是素数也不是合数,一开始把 1 也算进非素数里。后来确认语义后从 2 开始遍历,并单独写了 is_prime 函数让逻辑更清晰。
  2. 循环左移的越界:直接左移 n 次可能因 n 大于字符串长度而越界,且逐字符移动效率低。改用三步反转法并先 n %= len 取余,既安全又只用了 O(1) 空间。
  3. tolower 的负值 char 问题:直接用 tolower(*s1) 在 char 为负数时是未定义行为。改成 tolower((unsigned char)*s1),同时包含 <ctype.h>。
  4. %p 打印指针的格式警告:直接 printf("%p", &a[i]) 会因参数类型不是 void* 产生警告,改成 (void*)&a[i] 后消除。
  5. 二维数组传参:函数形参里第二维必须写常量(如 int a[][N]),否则无法正确计算元素偏移,这是二维数组做参数最容易出错的地方。

总结与思考

本次作业系统地练习了 C 语言的指针与数组,收获最大的是以下几点:

  1. 指针作为传出参数:如第(2)题的 k、第(10)题的 a、b,通过指针让函数返回多个值,这是 C 语言区别于其他语言的重要特性。
  2. 数组名与指针的等价性:arr[i]、*(p+i)、p[i] 三者等价,理解了这一点,指针运算就通了。
  3. 算法思维比蛮力更重要:第(9)题从左下角查找达到 O(m+n)、第(11)题三步反转达到 O(1) 空间,说明巧妙利用数据性质能大幅提升效率。
  4. 细节决定成败:非素数的边界、tolower 的类型安全、%p 的格式要求,都是容易踩坑的小细节,写代码时要有意识地规避。

通过这次作业,我对指针的"地址"本质有了更直观的理解——第(14)题打印出相邻元素相差 4 字节的地址,正是数组连续存储的最好证明。

posted @ 2026-11-19 16:08  grylls_teng  阅读(7)  评论(0)    收藏  举报