数组与字符串练习

15. 数组与字符串练习题

1. 数组初始化与遍历

题目描述： 编写一个 C 程序，初始化一个整数数组，包含 10 个元素，然后遍历并打印数组中的所有元素。

解题思路： 要初始化一个数组，可以在声明时直接给出初始值。遍历数组可以使用for循环，通过索引访问每个元素并打印。

程序流程如下：

1. 声明并初始化一个包含 10 个整数的数组。
2. 使用for循环遍历数组，从索引 0 到 9。
3. 在循环中打印每个数组元素。

详细代码：

#include <stdio.h>

int main() {
    // 声明并初始化一个包含10个整数的数组
    int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

    // 使用for循环遍历数组
    printf("数组中的元素为:\n");
    for(int i = 0; i < 10; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }

    return 0;
}

代码注释：

• int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};：声明并初始化一个包含 10 个整数的数组。
• for(int i = 0; i < 10; i++)：使用for循环从索引 0 到 9 遍历数组。
• printf("arr[%d] = %d\n", i, arr[i]);：打印当前索引和对应的数组元素。

2. 查找数组中的最大值和最小值

题目描述： 编写一个 C 程序，输入 10 个整数存储在数组中，找到并输出数组中的最大值和最小值。

解题思路： 要找到数组中的最大值和最小值，可以先假设第一个元素为最大值和最小值，然后遍历数组，比较每个元素与当前的最大值和最小值，进行更新。

程序流程如下：

1. 声明一个数组，大小为 10。
2. 提示用户输入 10 个整数，并存储在数组中。
3. 初始化max和min为数组的第一个元素。
4. 使用for循环遍历数组，从第二个元素开始比较。
5. 根据比较结果更新max和min。
6. 输出最大值和最小值。

详细代码：

#include <stdio.h>

int main() {
    int arr[10];
    int max, min;

    // 提示用户输入10个整数
    printf("请输入10个整数:\n");
    for(int i = 0; i < 10; i++) {
        scanf("%d", &arr[i]);
    }

    // 初始化max和min为第一个元素
    max = arr[0];
    min = arr[0];

    // 遍历数组，查找最大值和最小值
    for(int i = 1; i < 10; i++) {
        if(arr[i] > max) {
            max = arr[i];
        }
        if(arr[i] < min) {
            min = arr[i];
        }
    }

    // 输出结果
    printf("数组中的最大值是 %d。\n", max);
    printf("数组中的最小值是 %d。\n", min);

    return 0;
}

代码注释：

• int arr[10];：声明一个大小为 10 的整数数组。
• for(int i = 0; i < 10; i++)：循环读取用户输入的 10 个整数并存储在数组中。
• max = arr[0]; min = arr[0];：初始化最大值和最小值为数组的第一个元素。
• if(arr[i] > max)：如果当前元素大于max，更新max。
• if(arr[i] < min)：如果当前元素小于min，更新min。
• printf：输出数组中的最大值和最小值。

3. 数组元素求和与平均值

题目描述： 编写一个 C 程序，输入 5 个浮点数存储在数组中，计算并输出数组元素的总和和平均值。

解题思路： 要计算数组元素的总和，可以使用for循环将所有元素累加起来。平均值则是总和除以元素的数量。

程序流程如下：

1. 声明一个数组，大小为 5，类型为float。
2. 提示用户输入 5 个浮点数，并存储在数组中。
3. 使用for循环遍历数组，累加所有元素的值。
4. 计算平均值。
5. 输出总和和平均值。

详细代码：

#include <stdio.h>

int main() {
    float arr[5];
    float sum = 0.0, average;

    // 提示用户输入5个浮点数
    printf("请输入5个浮点数:\n");
    for(int i = 0; i < 5; i++) {
        scanf("%f", &arr[i]);
    }

    // 计算总和
    for(int i = 0; i < 5; i++) {
        sum += arr[i];
    }

    // 计算平均值
    average = sum / 5;

    // 输出结果
    printf("数组元素的总和是 %.2f。\n", sum);
    printf("数组元素的平均值是 %.2f。\n", average);

    return 0;
}

代码注释：

• float arr[5];：声明一个大小为 5 的浮点数数组。
• float sum = 0.0, average;：声明并初始化总和变量为 0，平均值变量。
• for(int i = 0; i < 5; i++)：循环读取用户输入的 5 个浮点数并存储在数组中。
• sum += arr[i];：将当前数组元素累加到sum中。
• average = sum / 5;：计算平均值。
• printf：输出总和和平均值。

4. 反转数组

题目描述： 编写一个 C 程序，输入 10 个整数存储在数组中，然后将数组中的元素反转，并输出反转后的数组。

解题思路： 要反转数组，可以使用两个指针（或索引）从数组的两端开始，交换对应位置的元素，直到中间位置。

程序流程如下：

1. 声明一个数组，大小为 10。
2. 提示用户输入 10 个整数，并存储在数组中。
3. 使用for循环，从数组的开始和结束，交换对应的元素。
4. 输出反转后的数组。

详细代码：

#include <stdio.h>

int main() {
    int arr[10];
    int temp;

    // 提示用户输入10个整数
    printf("请输入10个整数:\n");
    for(int i = 0; i < 10; i++) {
        scanf("%d", &arr[i]);
    }

    // 反转数组
    for(int i = 0; i < 10 / 2; i++) {
        temp = arr[i];
        arr[i] = arr[10 - 1 - i];
        arr[10 - 1 - i] = temp;
    }

    // 输出反转后的数组
    printf("反转后的数组元素为:\n");
    for(int i = 0; i < 10; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }

    return 0;
}

代码注释：

• int arr[10];：声明一个大小为 10 的整数数组。
• for(int i = 0; i < 10; i++)：循环读取用户输入的 10 个整数并存储在数组中。
• for(int i = 0; i < 10 / 2; i++)：循环遍历数组的一半，交换元素。
• temp = arr[i]; arr[i] = arr[10 - 1 - i]; arr[10 - 1 - i] = temp;：交换数组中对应位置的元素。
• for(int i = 0; i < 10; i++)：循环输出反转后的数组元素。

5. 数组排序（升序）

题目描述： 编写一个 C 程序，输入 5 个整数存储在数组中，对数组进行升序排序，并输出排序后的数组。

解题思路： 可以使用简单的排序算法，如冒泡排序。通过多次遍历数组，比较相邻元素并交换位置，使得最大的元素逐渐移动到数组的末尾。

程序流程如下：

1. 声明一个数组，大小为 5。
2. 提示用户输入 5 个整数，并存储在数组中。
3. 使用嵌套for循环实现冒泡排序。
4. 输出排序后的数组。

详细代码：

#include <stdio.h>

int main() {
    int arr[5];
    int temp;

    // 提示用户输入5个整数
    printf("请输入5个整数:\n");
    for(int i = 0; i < 5; i++) {
        scanf("%d", &arr[i]);
    }

    // 冒泡排序（升序）
    for(int i = 0; i < 5 - 1; i++) {
        for(int j = 0; j < 5 - 1 - i; j++) {
            if(arr[j] > arr[j + 1]) {
                // 交换arr[j]和arr[j + 1]
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }

    // 输出排序后的数组
    printf("升序排序后的数组元素为:\n");
    for(int i = 0; i < 5; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }

    return 0;
}

代码注释：

• int arr[5];：声明一个大小为 5 的整数数组。
• for(int i = 0; i < 5; i++)：循环读取用户输入的 5 个整数并存储在数组中。
• 冒泡排序部分：
  • 外层循环控制排序的次数，每次将最大的元素移动到未排序部分的末尾。
  • 内层循环比较并交换相邻的元素。
• printf：输出升序排序后的数组元素。

6. 数组排序（降序）

题目描述： 编写一个 C 程序，输入 5 个整数存储在数组中，对数组进行降序排序，并输出排序后的数组。

解题思路： 类似于升序排序，使用冒泡排序算法，但在比较时调整条件，使得较大的元素向前移动。

程序流程如下：

1. 声明一个数组，大小为 5。
2. 提示用户输入 5 个整数，并存储在数组中。
3. 使用嵌套for循环实现冒泡排序（降序）。
4. 输出排序后的数组。

详细代码：

#include <stdio.h>

int main() {
    int arr[5];
    int temp;

    // 提示用户输入5个整数
    printf("请输入5个整数:\n");
    for(int i = 0; i < 5; i++) {
        scanf("%d", &arr[i]);
    }

    // 冒泡排序（降序）
    for(int i = 0; i < 5 - 1; i++) {
        for(int j = 0; j < 5 - 1 - i; j++) {
            if(arr[j] < arr[j + 1]) {
                // 交换arr[j]和arr[j + 1]
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }

    // 输出排序后的数组
    printf("降序排序后的数组元素为:\n");
    for(int i = 0; i < 5; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }

    return 0;
}

代码注释：

• int arr[5];：声明一个大小为 5 的整数数组。
• for(int i = 0; i < 5; i++)：循环读取用户输入的 5 个整数并存储在数组中。
• 冒泡排序部分：
  • 外层循环控制排序的次数，每次将最小的元素移动到未排序部分的末尾。
  • 内层循环比较并交换相邻的元素，如果前一个元素小于后一个元素，则交换，确保较大的元素向前移动。
• printf：输出降序排序后的数组元素。

7. 二维数组的初始化与访问

题目描述： 编写一个 C 程序，声明并初始化一个 3x3 的二维整数数组，然后遍历并打印所有元素。

解题思路： 二维数组可以看作是数组的数组。初始化时可以在声明时直接给出二维元素。遍历二维数组需要使用嵌套的for循环，分别控制行和列的索引。

程序流程如下：

1. 声明并初始化一个 3x3 的二维整数数组。
2. 使用嵌套for循环遍历二维数组的行和列。
3. 在循环中打印每个数组元素。

详细代码：

#include <stdio.h>

int main() {
    // 声明并初始化一个3x3的二维数组
    int arr[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // 使用嵌套for循环遍历二维数组
    printf("二维数组的元素为:\n");
    for(int i = 0; i < 3; i++) { // 遍历行
        for(int j = 0; j < 3; j++) { // 遍历列
            printf("%d ", arr[i][j]);
        }
        printf("\n"); // 换行
    }

    return 0;
}

代码注释：

• int arr[3][3] = {...};：声明并初始化一个 3x3 的二维整数数组。
• for(int i = 0; i < 3; i++)：外层循环遍历数组的行。
• for(int j = 0; j < 3; j++)：内层循环遍历数组的列。
• printf("%d ", arr[i][j]);：打印当前元素。
• printf("\n");：每完成一行后换行。

8. 矩阵加法

题目描述： 编写一个 C 程序，输入两个 3x3 的矩阵，计算它们的和，并输出结果矩阵。

解题思路： 矩阵加法是对应位置元素相加。程序流程如下：

1. 声明两个 3x3 的矩阵 A 和 B。
2. 提示用户输入矩阵 A 和矩阵 B 的元素。
3. 使用嵌套for循环计算矩阵 A 和矩阵 B 的和，并存储在矩阵 C 中。
4. 输出结果矩阵 C。

详细代码：

#include <stdio.h>

int main() {
    int A[3][3], B[3][3], C[3][3];

    // 输入矩阵A
    printf("请输入矩阵A的元素（3x3）：\n");
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 3; j++) {
            printf("A[%d][%d] = ", i, j);
            scanf("%d", &A[i][j]);
        }
    }

    // 输入矩阵B
    printf("请输入矩阵B的元素（3x3）：\n");
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 3; j++) {
            printf("B[%d][%d] = ", i, j);
            scanf("%d", &B[i][j]);
        }
    }

    // 计算矩阵C = A + B
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 3; j++) {
            C[i][j] = A[i][j] + B[i][j];
        }
    }

    // 输出结果矩阵C
    printf("矩阵A + 矩阵B 的和为:\n");
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 3; j++) {
            printf("%d ", C[i][j]);
        }
        printf("\n");
    }

    return 0;
}

代码注释：

• int A[3][3], B[3][3], C[3][3];：声明三个 3x3 的整数矩阵 A、B 和 C。
• 输入矩阵 A 和矩阵 B：
  • 使用嵌套for循环读取用户输入的矩阵元素。
• 计算矩阵 C：
  • 使用嵌套for循环，将 A 和 B 对应位置的元素相加，并存储在 C 中。
• 输出矩阵 C：
  • 使用嵌套for循环打印矩阵 C 的元素。

9. 矩阵乘法

题目描述： 编写一个 C 程序，输入两个 2x3 和 3x2 的矩阵，计算它们的乘积，并输出结果矩阵。

解题思路： 矩阵乘法要求第一个矩阵的列数等于第二个矩阵的行数。乘积矩阵的行数为第一个矩阵的行数，列数为第二个矩阵的列数。每个元素的计算为对应行与列元素的乘积之和。

程序流程如下：

1. 声明两个矩阵 A（2x3）和 B（3x2）。
2. 输入矩阵 A 和矩阵 B 的元素。
3. 声明结果矩阵 C（2x2），初始化为 0。
4. 使用嵌套for循环计算矩阵乘积。
5. 输出结果矩阵 C。

详细代码：

#include <stdio.h>

int main() {
    int A[2][3], B[3][2], C[2][2] = {0};

    // 输入矩阵A
    printf("请输入矩阵A的元素（2x3）：\n");
    for(int i = 0; i < 2; i++) {
        for(int j = 0; j < 3; j++) {
            printf("A[%d][%d] = ", i, j);
            scanf("%d", &A[i][j]);
        }
    }

    // 输入矩阵B
    printf("请输入矩阵B的元素（3x2）：\n");
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 2; j++) {
            printf("B[%d][%d] = ", i, j);
            scanf("%d", &B[i][j]);
        }
    }

    // 计算矩阵C = A * B
    for(int i = 0; i < 2; i++) { // 矩阵A的行
        for(int j = 0; j < 2; j++) { // 矩阵B的列
            for(int k = 0; k < 3; k++) { // 矩阵A的列 / 矩阵B的行
                C[i][j] += A[i][k] * B[k][j];
            }
        }
    }

    // 输出结果矩阵C
    printf("矩阵A * 矩阵B 的乘积为:\n");
    for(int i = 0; i < 2; i++) {
        for(int j = 0; j < 2; j++) {
            printf("%d ", C[i][j]);
        }
        printf("\n");
    }

    return 0;
}

代码注释：

• int A[2][3], B[3][2], C[2][2] = {0};：声明两个矩阵 A（2x3）和 B（3x2），以及结果矩阵 C（2x2），初始化为 0。
• 输入矩阵 A 和矩阵 B：
  • 使用嵌套for循环读取用户输入的矩阵元素。
• 计算矩阵 C：
  • 使用三重嵌套for循环进行矩阵乘法。
  • C[i][j] += A[i][k] * B[k][j];：计算乘积矩阵 C 的每个元素。
• 输出矩阵 C：
  • 使用嵌套for循环打印矩阵 C 的元素。

10. 字符串复制

题目描述： 编写一个 C 程序，输入一个字符串，将其复制到另一个字符串，并输出复制后的字符串。

解题思路： 使用字符数组存储输入字符串和复制后的字符串。遍历输入字符串，将每个字符赋值给目标字符串，直到遇到字符串结束符\0。

程序流程如下：

1. 声明两个字符数组，一个用于存储输入字符串，另一个用于复制。
2. 提示用户输入一个字符串。
3. 使用for循环或while循环复制字符到目标字符串。
4. 确保目标字符串以\0结束。
5. 输出复制后的字符串。

详细代码：

#include <stdio.h>

int main() {
    char source[100], destination[100];
    int i;

    // 提示用户输入一个字符串
    printf("请输入一个字符串: ");
    fgets(source, sizeof(source), stdin); // 使用fgets读取包含空格的字符串

    // 复制字符串
    for(i = 0; source[i] != '\0'; i++) {
        destination[i] = source[i];
    }
    destination[i] = '\0'; // 添加字符串结束符

    // 输出复制后的字符串
    printf("复制后的字符串是: %s\n", destination);

    return 0;
}

代码注释：

• char source[100], destination[100];：声明两个字符数组，分别用于源字符串和目标字符串。
• fgets(source, sizeof(source), stdin);：使用fgets读取用户输入的字符串，包含空格。
• for(i = 0; source[i] != '\0'; i++)：循环遍历源字符串，复制每个字符到目标字符串。
• destination[i] = '\0';：确保目标字符串以\0结束。
• printf：输出复制后的字符串。

11. 字符串连接

题目描述： 编写一个 C 程序，输入两个字符串，将第二个字符串连接到第一个字符串的末尾，并输出结果。

解题思路： 在第一个字符串的末尾找到\0，然后将第二个字符串的字符逐一复制到第一个字符串的末尾，最后添加\0结束符。

程序流程如下：

1. 声明两个字符数组，一个用于存储第一个字符串，另一个用于存储第二个字符串。
2. 提示用户输入两个字符串。
3. 找到第一个字符串的结束位置。
4. 使用for循环将第二个字符串的字符复制到第一个字符串的末尾。
5. 添加字符串结束符\0。
6. 输出连接后的字符串。

详细代码：

#include <stdio.h>

int main() {
    char str1[200], str2[100];
    int i, j;

    // 提示用户输入第一个字符串
    printf("请输入第一个字符串: ");
    fgets(str1, sizeof(str1), stdin);

    // 去除str1中的换行符
    for(i = 0; str1[i] != '\0'; i++) {
        if(str1[i] == '\n') {
            str1[i] = '\0';
            break;
        }
    }

    // 提示用户输入第二个字符串
    printf("请输入第二个字符串: ");
    fgets(str2, sizeof(str2), stdin);

    // 去除str2中的换行符
    for(j = 0; str2[j] != '\0'; j++) {
        if(str2[j] == '\n') {
            str2[j] = '\0';
            break;
        }
    }

    // 连接字符串
    int k = i; // k指向str1的结束位置
    for(j = 0; str2[j] != '\0'; j++, k++) {
        str1[k] = str2[j];
    }
    str1[k] = '\0'; // 添加字符串结束符

    // 输出连接后的字符串
    printf("连接后的字符串是: %s\n", str1);

    return 0;
}

代码注释：

• char str1[200], str2[100];：声明两个字符数组，分别用于存储第一个字符串和第二个字符串。
• fgets(str1, sizeof(str1), stdin); 和 fgets(str2, sizeof(str2), stdin);：使用fgets读取用户输入的字符串。
• 去除换行符：遍历字符串，遇到\n则替换为\0。
• int k = i;：设置k为第一个字符串的结束位置。
• for(j = 0; str2[j] != '\0'; j++, k++)：循环复制第二个字符串的字符到第一个字符串的末尾。
• str1[k] = '\0';：确保连接后的字符串以\0结束。
• printf：输出连接后的字符串。

12. 字符串长度计算

题目描述： 编写一个 C 程序，输入一个字符串，计算并输出该字符串的长度。

解题思路： 遍历字符串，直到遇到字符串结束符\0，统计字符的数量即为字符串的长度。

程序流程如下：

1. 声明一个字符数组用于存储输入字符串。
2. 提示用户输入一个字符串。
3. 使用for循环遍历字符串，计数字符数。
4. 输出字符串的长度。

详细代码：

#include <stdio.h>

int main() {
    char str[100];
    int length = 0;

    // 提示用户输入一个字符串
    printf("请输入一个字符串: ");
    fgets(str, sizeof(str), stdin);

    // 计算字符串长度
    for(int i = 0; str[i] != '\0'; i++) {
        if(str[i] == '\n') {
            break; // 遇到换行符则停止
        }
        length++;
    }

    // 输出字符串长度
    printf("字符串的长度是 %d。\n", length);

    return 0;
}

代码注释：

• char str[100];：声明一个字符数组用于存储输入字符串。
• fgets(str, sizeof(str), stdin);：使用fgets读取用户输入的字符串，包括空格。
• for(int i = 0; str[i] != '\0'; i++)：遍历字符串直到\0。
• if(str[i] == '\n')：如果遇到换行符，停止计数。
• length++：统计字符数。
• printf：输出字符串的长度。

13. 字符串反转

题目描述： 编写一个 C 程序，输入一个字符串，将其反转并输出。

解题思路： 首先计算字符串的长度，然后使用两个指针（或索引），一个从字符串开头，一个从末尾，逐一交换对应的字符，直到中间位置。

程序流程如下：

1. 声明两个字符数组，一个用于存储输入字符串，另一个用于存储反转后的字符串。
2. 提示用户输入一个字符串。
3. 计算字符串的长度。
4. 使用for循环，从字符串的末尾开始，将字符复制到目标字符串的前面。
5. 添加字符串结束符\0。
6. 输出反转后的字符串。

详细代码：

#include <stdio.h>

int main() {
    char source[100], reversed[100];
    int length = 0;

    // 提示用户输入一个字符串
    printf("请输入一个字符串: ");
    fgets(source, sizeof(source), stdin);

    // 计算字符串长度，去除换行符
    while(source[length] != '\0') {
        if(source[length] == '\n') {
            break;
        }
        length++;
    }

    // 反转字符串
    for(int i = 0; i < length; i++) {
        reversed[i] = source[length - 1 - i];
    }
    reversed[length] = '\0'; // 添加字符串结束符

    // 输出反转后的字符串
    printf("反转后的字符串是: %s\n", reversed);

    return 0;
}

代码注释：

• char source[100], reversed[100];：声明两个字符数组，分别用于源字符串和反转后的字符串。
• fgets(source, sizeof(source), stdin);：读取用户输入的字符串。
• 计算字符串长度并去除换行符：
  • 遍历字符串，遇到\n则停止计数。
• for(int i = 0; i < length; i++)：循环将源字符串的字符从末尾复制到目标字符串的前面。
• reversed[length] = '\0';：确保反转后的字符串以\0结束。
• printf：输出反转后的字符串。

14. 字符串查找子字符串

题目描述： 编写一个 C 程序，输入两个字符串，判断第二个字符串是否为第一个字符串的子字符串，并输出结果。

解题思路： 使用嵌套循环遍历第一个字符串，查找第二个字符串是否连续出现在第一个字符串中。如果找到匹配，则说明第二个字符串是第一个字符串的子字符串。

程序流程如下：

1. 声明两个字符数组，一个用于存储主字符串，另一个用于存储子字符串。
2. 提示用户输入两个字符串。
3. 遍历主字符串，寻找子字符串的起始位置。
4. 如果找到匹配的子字符串，设置标志位。
5. 根据标志位输出结果。

详细代码：

#include <stdio.h>

int main() {
    char str[100], substr[100];
    int i, j, found = 0;

    // 提示用户输入主字符串
    printf("请输入主字符串: ");
    fgets(str, sizeof(str), stdin);

    // 去除主字符串中的换行符
    for(i = 0; str[i] != '\0'; i++) {
        if(str[i] == '\n') {
            str[i] = '\0';
            break;
        }
    }

    // 提示用户输入子字符串
    printf("请输入子字符串: ");
    fgets(substr, sizeof(substr), stdin);

    // 去除子字符串中的换行符
    for(j = 0; substr[j] != '\0'; j++) {
        if(substr[j] == '\n') {
            substr[j] = '\0';
            break;
        }
    }

    // 查找子字符串
    for(i = 0; str[i] != '\0'; i++) {
        int k = i;
        int l = 0;
        while(str[k] == substr[l] && substr[l] != '\0') {
            k++;
            l++;
        }
        if(substr[l] == '\0') {
            found = 1;
            break;
        }
    }

    // 输出结果
    if(found) {
        printf("子字符串 \"%s\" 是主字符串的子字符串。\n", substr);
    } else {
        printf("子字符串 \"%s\" 不是主字符串的子字符串。\n", substr);
    }

    return 0;
}

代码注释：

• char str[100], substr[100];：声明两个字符数组，分别用于主字符串和子字符串。
• fgets(str, sizeof(str), stdin); 和 fgets(substr, sizeof(substr), stdin);：使用fgets读取用户输入的字符串。
• 去除换行符：遍历字符串，遇到\n则替换为\0。
• 查找子字符串：
  • 使用外层for循环遍历主字符串。
  • 内层while循环比较主字符串和子字符串的字符。
  • 如果子字符串完全匹配，设置found为 1 并退出循环。
• if(found)：根据found的值输出是否为子字符串的结果。

15. 判断回文字符串

题目描述： 编写一个 C 程序，输入一个字符串，判断该字符串是否是回文字符串（正读和反读相同），并输出结果。

解题思路： 回文字符串的特点是从左到右和从右到左读是相同的。可以通过比较字符串的前后对应字符来判断。

程序流程如下：

1. 声明一个字符数组用于存储输入字符串。
2. 提示用户输入一个字符串。
3. 计算字符串的长度。
4. 使用for循环比较字符串的前后对应字符。
5. 如果所有对应字符相同，则是回文字符串。
6. 输出判断结果。

详细代码：

#include <stdio.h>
#include <ctype.h> // 用于tolower函数

int main() {
    char str[100];
    int length = 0;
    int isPalindrome = 1;

    // 提示用户输入一个字符串
    printf("请输入一个字符串: ");
    fgets(str, sizeof(str), stdin);

    // 计算字符串长度，去除换行符
    while(str[length] != '\0') {
        if(str[length] == '\n') {
            str[length] = '\0';
            break;
        }
        length++;
    }

    // 比较前后字符
    for(int i = 0; i < length / 2; i++) {
        // 将字符转换为小写以忽略大小写差异
        if(tolower(str[i]) != tolower(str[length - 1 - i])) {
            isPalindrome = 0;
            break;
        }
    }

    // 输出结果
    if(isPalindrome) {
        printf("字符串 \"%s\" 是回文字符串。\n", str);
    } else {
        printf("字符串 \"%s\" 不是回文字符串。\n", str);
    }

    return 0;
}

代码注释：

• char str[100];：声明一个字符数组用于存储输入字符串。
• fgets(str, sizeof(str), stdin);：读取用户输入的字符串。
• 计算字符串长度并去除换行符：
  • 遍历字符串，遇到\n则替换为\0。
• for(int i = 0; i < length / 2; i++)：循环比较前后对应字符。
• tolower(str[i]) 和 tolower(str[length - 1 - i])：将字符转换为小写，忽略大小写差异。
• if(tolower(str[i]) != tolower(str[length - 1 - i]))：如果有任何一对字符不相同，则不是回文字符串。
• if(isPalindrome)：根据isPalindrome的值输出是否为回文字符串。

16. 数组元素去重

题目描述： 编写一个 C 程序，输入一组整数存储在数组中，去除数组中的重复元素，并输出去重后的数组。

解题思路： 遍历数组，对于每个元素，检查它之前是否已经存在相同的元素。如果不存在，则将其保留；否则，跳过。可以使用一个辅助数组来存储去重后的元素。

程序流程如下：

1. 声明两个数组，一个用于存储原始数据，另一个用于存储去重后的数据。
2. 提示用户输入数组的大小和元素。
3. 使用嵌套for循环检查重复元素。
4. 将不重复的元素存储到辅助数组中。
5. 输出去重后的数组。

详细代码：

#include <stdio.h>

int main() {
    int arr[100], unique[100];
    int n, uniqueCount = 0;
    int isDuplicate;

    // 提示用户输入数组大小
    printf("请输入数组的大小 (最多100个元素): ");
    scanf("%d", &n);

    // 输入数组元素
    printf("请输入 %d 个整数:\n", n);
    for(int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    // 去重
    for(int i = 0; i < n; i++) {
        isDuplicate = 0;
        for(int j = 0; j < uniqueCount; j++) {
            if(arr[i] == unique[j]) {
                isDuplicate = 1;
                break;
            }
        }
        if(!isDuplicate) {
            unique[uniqueCount++] = arr[i];
        }
    }

    // 输出去重后的数组
    printf("去重后的数组元素为:\n");
    for(int i = 0; i < uniqueCount; i++) {
        printf("unique[%d] = %d\n", i, unique[i]);
    }

    return 0;
}

代码注释：

• int arr[100], unique[100];：声明两个数组，一个用于存储原始数据，另一个用于存储去重后的数据。
• int count = 0;：声明一个变量用于记录去重后的元素数量。
• for(int i = 0; i < n; i++)：遍历原始数组的每个元素。
• 内层for(int j = 0; j < uniqueCount; j++)：检查当前元素是否已经存在于unique数组中。
• if(arr[i] == unique[j])：如果找到重复元素，设置isDuplicate为 1，并跳出内层循环。
• if(!isDuplicate)：如果元素不重复，添加到unique数组中，并增加uniqueCount。
• for(int i = 0; i < uniqueCount; i++)：输出去重后的数组元素。

17. 查找数组中的特定元素

题目描述： 编写一个 C 程序，输入一组整数存储在数组中，输入一个目标值，查找目标值在数组中的位置并输出。如果不存在，输出提示信息。

解题思路： 遍历数组，比较每个元素是否等于目标值。如果找到，则记录其位置并输出。如果遍历完数组后未找到目标值，输出不存在的提示。

程序流程如下：

1. 声明一个数组。
2. 提示用户输入数组的大小和元素。
3. 提示用户输入目标值。
4. 使用for循环遍历数组，查找目标值。
5. 如果找到，输出其位置；否则，输出不存在的提示。

详细代码：

#include <stdio.h>

int main() {
    int arr[100];
    int n, target, found = 0;

    // 提示用户输入数组大小
    printf("请输入数组的大小 (最多100个元素): ");
    scanf("%d", &n);

    // 输入数组元素
    printf("请输入 %d 个整数:\n", n);
    for(int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    // 输入目标值
    printf("请输入要查找的目标值: ");
    scanf("%d", &target);

    // 查找目标值
    for(int i = 0; i < n; i++) {
        if(arr[i] == target) {
            printf("目标值 %d 在数组中的位置是索引 %d。\n", target, i);
            found = 1;
            break; // 如果只需要找到第一个匹配项，可以退出循环
        }
    }

    if(!found) {
        printf("目标值 %d 不存在于数组中。\n", target);
    }

    return 0;
}

代码注释：

• int arr[100];：声明一个最大大小为 100 的整数数组。
• printf 和 scanf：提示用户输入数组大小、元素和目标值。
• for(int i = 0; i < n; i++)：遍历数组，查找目标值。
• if(arr[i] == target)：如果找到目标值，输出其索引并设置found为 1。
• if(!found)：如果遍历完数组未找到目标值，输出不存在的提示。

18. 数组中元素的频率统计

题目描述： 编写一个 C 程序，输入一组整数存储在数组中，统计并输出每个元素出现的频率。

解题思路： 使用一个辅助数组记录每个元素的出现次数。遍历原始数组，对于每个元素，检查它是否已经被统计过。如果未被统计，则遍历数组计算其出现次数，并输出。

程序流程如下：

1. 声明两个数组，一个用于存储原始数据，另一个用于存储已统计的元素。
2. 提示用户输入数组的大小和元素。
3. 使用嵌套for循环统计每个元素的频率。
4. 输出每个元素及其出现次数。

详细代码：

#include <stdio.h>

int main() {
    int arr[100], unique[100];
    int count[100] = {0};
    int n, uniqueCount = 0;

    // 提示用户输入数组大小
    printf("请输入数组的大小 (最多100个元素): ");
    scanf("%d", &n);

    // 输入数组元素
    printf("请输入 %d 个整数:\n", n);
    for(int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    // 统计频率
    for(int i = 0; i < n; i++) {
        int j;
        // 检查arr[i]是否已经存在于unique数组中
        for(j = 0; j < uniqueCount; j++) {
            if(arr[i] == unique[j]) {
                count[j]++;
                break;
            }
        }
        // 如果arr[i]不在unique数组中，添加进去
        if(j == uniqueCount) {
            unique[uniqueCount] = arr[i];
            count[uniqueCount] = 1;
            uniqueCount++;
        }
    }

    // 输出每个元素的频率
    printf("元素及其出现的频率为:\n");
    for(int i = 0; i < uniqueCount; i++) {
        printf("元素 %d 出现了 %d 次\n", unique[i], count[i]);
    }

    return 0;
}

代码注释：

• int arr[100], unique[100];：声明两个数组，一个用于存储原始数据，另一个用于存储已统计的唯一元素。
• int count[100] = {0};：声明并初始化一个数组用于记录每个唯一元素的出现次数。
• for(int i = 0; i < n; i++)：遍历原始数组。
• 内层for(j = 0; j < uniqueCount; j++)：检查当前元素是否已经存在于unique数组中。
• if(arr[i] == unique[j])：如果找到重复元素，增加对应的计数。
• if(j == uniqueCount)：如果元素未被统计过，添加到unique数组中，并初始化计数为 1。
• for(int i = 0; i < uniqueCount; i++)：遍历unique数组，输出每个元素及其出现次数。

19. 多维数组的元素求和

题目描述： 编写一个 C 程序，输入一个 3x3 的二维数组，计算并输出所有元素的总和。

解题思路： 遍历二维数组，累加每个元素的值到总和变量中。

程序流程如下：

1. 声明一个 3x3 的二维整数数组。
2. 提示用户输入矩阵的元素。
3. 使用嵌套for循环遍历矩阵，累加元素值。
4. 输出总和。

详细代码：

#include <stdio.h>

int main() {
    int arr[3][3];
    int sum = 0;

    // 输入二维数组元素
    printf("请输入3x3的二维数组元素:\n");
    for(int i = 0; i < 3; i++) { // 遍历行
        for(int j = 0; j < 3; j++) { // 遍历列
            printf("arr[%d][%d] = ", i, j);
            scanf("%d", &arr[i][j]);
            sum += arr[i][j]; // 累加元素值
        }
    }

    // 输出总和
    printf("二维数组所有元素的总和是 %d。\n", sum);

    return 0;
}

代码注释：

• int arr[3][3];：声明一个 3x3 的整数数组。
• int sum = 0;：声明并初始化总和变量为 0。
• 输入矩阵元素：
  • 使用嵌套for循环遍历每个元素，读取用户输入并累加到sum中。
• printf：输出所有元素的总和。

20. 使用数组实现简单的动态列表

题目描述： 编写一个 C 程序，使用数组实现一个简单的动态列表，允许用户添加、删除和显示元素。程序应提供一个菜单供用户选择操作，直到用户选择退出。

解题思路： 使用一个数组和一个变量来跟踪当前元素的数量。提供菜单选项包括添加元素、删除元素（按索引）、显示所有元素以及退出程序。使用switch语句根据用户的选择执行相应的操作。

程序流程如下：

1. 声明一个数组和一个变量用于存储当前元素数量。
2. 使用do-while循环显示菜单并处理用户选择。
3. 根据选择，执行添加、删除、显示或退出操作。
4. 添加操作：
   • 检查数组是否已满。
   • 读取新元素并添加到数组末尾。
5. 删除操作：
   • 提示用户输入要删除的索引。
   • 检查索引是否有效。
   • 将该索引后的元素左移一位。
6. 显示操作：
   • 遍历数组并打印所有元素。
7. 退出操作：
   • 结束循环并退出程序。

详细代码：

#include <stdio.h>

#define MAX_SIZE 100

int main() {
    int list[MAX_SIZE];
    int count = 0;
    int choice, value, index;

    // 菜单循环
    do {
        // 显示菜单
        printf("\n--- 动态列表菜单 ---\n");
        printf("1. 添加元素\n");
        printf("2. 删除元素\n");
        printf("3. 显示所有元素\n");
        printf("4. 退出\n");
        printf("请选择操作 (1-4): ");
        scanf("%d", &choice);

        switch(choice) {
            case 1:
                // 添加元素
                if(count >= MAX_SIZE) {
                    printf("列表已满，无法添加新元素。\n");
                } else {
                    printf("请输入要添加的元素: ");
                    scanf("%d", &value);
                    list[count++] = value;
                    printf("元素 %d 已添加。\n", value);
                }
                break;
            case 2:
                // 删除元素
                if(count == 0) {
                    printf("列表为空，无法删除元素。\n");
                } else {
                    printf("请输入要删除的元素的索引 (0 到 %d): ", count - 1);
                    scanf("%d", &index);
                    if(index < 0 || index >= count) {
                        printf("无效的索引。\n");
                    } else {
                        printf("元素 %d 已删除。\n", list[index]);
                        // 将后面的元素左移一位
                        for(int i = index; i < count - 1; i++) {
                            list[i] = list[i + 1];
                        }
                        count--;
                    }
                }
                break;
            case 3:
                // 显示所有元素
                if(count == 0) {
                    printf("列表为空。\n");
                } else {
                    printf("列表中的元素为:\n");
                    for(int i = 0; i < count; i++) {
                        printf("list[%d] = %d\n", i, list[i]);
                    }
                }
                break;
            case 4:
                // 退出
                printf("退出程序。\n");
                break;
            default:
                printf("无效的选择，请重新选择。\n");
        }
    } while(choice != 4);

    return 0;
}

代码注释：

• #define MAX_SIZE 100：定义数组的最大容量为 100。

• int list[MAX_SIZE];：声明一个数组用于存储元素。

• int count = 0;：声明并初始化元素数量为 0。

• 菜单循环：

  • do { ... } while(choice != 4);：循环显示菜单，直到用户选择退出。

  • switch(choice)
    

    ：根据用户的选择执行不同的操作。

    • case 1：添加元素，检查数组是否已满，读取新元素并添加到数组末尾。
    • case 2：删除元素，检查数组是否为空，读取要删除的索引，验证索引有效性，删除指定元素并将后面的元素左移。
    • case 3：显示所有元素，遍历数组并打印每个元素。
    • case 4：退出程序。
    • default：处理无效的选择，提示用户重新选择。

• printf 和 scanf：用于用户交互，读取输入和显示输出。