c语言编程题经典100例——（26~30例）

1，从键盘输入一个整数，判断它是正数、负数还是零。

以下是使用C语言编写的程序，可以从键盘输入一个整数，并判断它是正数、负数还是零：

#include   
  
int main() {  
    int num;  
    printf("请输入一个整数：");  
    scanf("%d", &num);  
    if (num > 0) {  
        printf("您输入的是正数。\n");  
    } else if (num < 0) {  
        printf("您输入的是负数。\n");  
    } else {  
        printf("您输入的是零。\n");  
    }  
    return 0;  
}

解释：

1. #include ：包含标准输入输出头文件。
2. int main()：程序的主函数。
3. int num;：定义一个整数变量 num。
4. printf("请输入一个整数：");：输出提示信息。
5. scanf("%d", &num);：从键盘输入一个整数，并存储到变量 num 中。
6. if (num > 0)：如果 num 大于零，表示它是正数。
7. printf("您输入的是正数。\n");：输出判断结果。
8. else if (num < 0)：如果 num 小于零，表示它是负数。
9. printf("您输入的是负数。\n");：输出判断结果。
10. else：如果 num 等于零。
11. printf("您输入的是零。\n");：输出判断结果。
12. return 0;：程序正常结束，返回值为零。

2，从键盘输入一个字符，判断它是大写字母、小写字母还是其他字符。

下面是一个使用C语言编写的程序，可以从键盘输入一个字符，判断它是大写字母、小写字母还是其他字符：

#include   
  
int main() {  
    char ch;  
    printf("请输入一个字符：");  
    scanf("%c", &ch);  
    if (ch >= 'A' && ch <= 'Z') {  
        printf("您输入的是大写字母。\n");  
    } else if (ch >= 'a' && ch <= 'z') {  
        printf("您输入的是小写字母。\n");  
    } else {  
        printf("您输入的是其他字符。\n");  
    }  
    return 0;  
}

解释：

1. #include ：包含标准输入输出头文件。
2. int main()：程序的主函数。
3. char ch;：定义一个字符变量 ch。
4. printf("请输入一个字符：");：输出提示信息。
5. scanf("%c", &ch);：从键盘输入一个字符，并存储到变量 ch 中。
6. if (ch >= 'A' && ch <= 'Z')：如果 ch 的ASCII码值在大写字母的范围内，表示它是大写字母。
7. printf("您输入的是大写字母。\n");：输出判断结果。
8. else if (ch >= 'a' && ch <= 'z')：如果 ch 的ASCII码值在小写字母的范围内，表示它是小写字母。
9. printf("您输入的是小写字母。\n");：输出判断结果。
10. else：如果 ch 的ASCII码值既不在大写字母的范围内，也不在小写字母的范围内，表示它是其他字符。
11. printf("您输入的是其他字符。\n");：输出判断结果。
12. return 0;：程序正常结束，返回值为零。

3，求解汉诺塔问题。

汉诺塔问题是一个经典的递归问题，可以使用C语言进行求解。以下是一个简单的C语言程序，用于求解汉诺塔问题：

#include   
  
void hanoi(int n, char A, char B, char C) {  
    if (n == 1) {  
        printf("Move disk 1 from %c to %c\n", A, C);  
        return;  
    }  
    hanoi(n - 1, A, C, B);  
    printf("Move disk %d from %c to %c\n", n, A, C);  
    hanoi(n - 1, B, A, C);  
}  
  
int main() {  
    int n;  
    printf("请输入汉诺塔的层数：");  
    scanf("%d", &n);  
    hanoi(n, 'A', 'B', 'C');  
    return 0;  
}

解释：

1. void hanoi(int n, char A, char B, char C)：定义一个名为 hanoi 的函数，用于求解汉诺塔问题。该函数接受四个参数：汉诺塔的层数 n，以及三个字符 A、B、C，分别表示三个柱子。
2. if (n == 1)：如果汉诺塔只有一层，则直接将盘子从起始柱子移动到目标柱子，并输出移动的信息。然后返回。
3. hanoi(n - 1, A, C, B)：递归调用 hanoi 函数，将前 n-1 个盘子从起始柱子 A 移动到辅助柱子 B 上，以 C 作为中间柱子。输出移动的信息。
4. printf("Move disk %d from %c to %c\n", n, A, C)：将第 n 个盘子从起始柱子 A 移动到目标柱子 C 上，并输出移动的信息。
5. hanoi(n - 1, B, A, C)：递归调用 hanoi 函数，将前 n-1 个盘子从辅助柱子 B 移动到目标柱子 C 上，以 A 作为中间柱子。输出移动的信息。
6. int main()：程序的主函数。首先提示用户输入汉诺塔的层数，并读入该值。然后调用 hanoi 函数求解汉诺塔问题。

4，求解最大子序和问题。

最大子序和问题是一个经典的动态规划问题，可以使用C语言实现。以下是一个简单的C语言程序，用于求解最大子序和问题：

#include   
#include   
  
int maxSubArray(int* nums, int numsSize) {  
    int max_so_far = nums[0];  
    int curr_max = nums[0];  
    for (int i = 1; i < numsSize; i++) {  
        curr_max = (curr_max + nums[i] > nums[i]) ? curr_max + nums[i] : nums[i];  
        max_so_far = (max_so_far > curr_max) ? max_so_far : curr_max;  
    }  
    return max_so_far;  
}  
  
int main() {  
    int nums[] = {-2, 1, -3, 4, -1, 2, 1, -5, 4};  
    int numsSize = sizeof(nums) / sizeof(nums[0]);  
    int maxSum = maxSubArray(nums, numsSize);  
    printf("The maximum subarray sum is %d\n", maxSum);  
    return 0;  
}

解释：

1. maxSubArray函数用于求解最大子序和。它接受一个整数数组nums和数组的大小numsSize作为参数。
2. 在函数中，我们使用两个变量max_so_far和curr_max来记录最大子序和。max_so_far用于记录已经找到的最大子序和，而curr_max则用于记录当前的最大子序和。
3. 我们使用一个循环遍历整个数组。对于每个元素，我们将其与curr_max相加，并检查结果是否比当前的最大子序和大。如果是，则更新curr_max为两者之和；否则，将curr_max设置为该元素的值。然后，我们比较max_so_far和curr_max的值，并将较大的值赋给max_so_far。
4. 最后，我们返回max_so_far作为结果。
5. 在主函数中，我们定义了一个整数数组nums，并将其传递给maxSubArray函数进行求解。然后，我们输出最大子序和的结果。

5，求解最小生成树问题。

最小生成树问题是一个经典的算法问题，其中Kruskal算法和Prim算法是两种最常用的解决方法。以下是使用C语言实现这两种算法的代码示例：

下面以Kruskal算法：

#include   
#include   
  
// 定义边的结构体  
typedef struct Edge {  
    int u, v, weight;  
} Edge;  
  
// 并查集  
int parent[100];  
int find(int i) {  
    if (parent[i] == i) return i;  
    return parent[i] = find(parent[i]);  
}  
  
// Kruskal算法求解最小生成树  
int kruskal(int V, Edge* edges, int E) {  
    int i, u, v, weight, MST_weight = 0;  
    Edge result[V];  
    for (i = 0; i < V; ++i) parent[i] = i;  
    qsort(edges, E, sizeof(Edge), (void*)compare);  
    for (i = 0; i < E; ++i) {  
        u = find(edges[i].u);  
        v = find(edges[i].v);  
        if (u != v) {  
            result[i] = edges[i];  
            MST_weight += edges[i].weight;  
            parent[u] = parent[v];  
        }  
    }  
    printf("Edges in the constructed MST\n");  
    for (i = 0; i < V - 1; ++i) {  
        printf("%d -- %d == %d\n", result[i].u, result[i].v, result[i].weight);  
    }  
    return MST_weight;  
}  
  
// 比较函数，用于快速排序算法  
int compare(const void* a, const void* b) {  
    Edge* edge1 = (Edge*)a;  
    Edge* edge2 = (Edge*)b;  
    return edge1->weight - edge2->weight;  
}  
  
int main() {  
    int V = 4;  // 顶点数量  
    Edge edges[] = {{0, 1, 10}, {0, 2, 6}, {0, 3, 5}, {1, 3, 15}, {2, 3, 4}};  // 边集合  
    kruskal(V, edges, 5);  // 求解最小生成树问题  
    return 0;  
}