c语言编程题经典100例——(26~30例)

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

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

#include <stdio.h>

int main() {

int num;

printf("请输入一个整数：");

scanf("%d", &num);

if (num > 0) {

printf("您输入的是正数。\n");

} else if (num < 0) {

printf("您输入的是负数。\n");

} else {

printf("您输入的是零。\n");

}

return 0;

}

解释：

#include <stdio.h>：包含标准输入输出头文件。

int main()：程序的主函数。

int num;：定义一个整数变量 num。

printf("请输入一个整数：");：输出提示信息。

scanf("%d", &num);：从键盘输入一个整数，并存储到变量 num 中。

if (num > 0)：如果 num 大于零，表示它是正数。

printf("您输入的是正数。\n");：输出判断结果。

else if (num < 0)：如果 num 小于零，表示它是负数。

printf("您输入的是负数。\n");：输出判断结果。

else：如果 num 等于零。

printf("您输入的是零。\n");：输出判断结果。

return 0;：程序正常结束，返回值为零。

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

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

#include <stdio.h>

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;

}

解释：

#include <stdio.h>：包含标准输入输出头文件。

int main()：程序的主函数。

char ch;：定义一个字符变量 ch。

printf("请输入一个字符：");：输出提示信息。

scanf("%c", &ch);：从键盘输入一个字符，并存储到变量 ch 中。

if (ch >= 'A' && ch <= 'Z')：如果 ch 的ASCII码值在大写字母的范围内，表示它是大写字母。

printf("您输入的是大写字母。\n");：输出判断结果。

else if (ch >= 'a' && ch <= 'z')：如果 ch 的ASCII码值在小写字母的范围内，表示它是小写字母。

printf("您输入的是小写字母。\n");：输出判断结果。

else：如果 ch 的ASCII码值既不在大写字母的范围内，也不在小写字母的范围内，表示它是其他字符。

printf("您输入的是其他字符。\n");：输出判断结果。

return 0;：程序正常结束，返回值为零。

3，求解汉诺塔问题。

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

#include <stdio.h>

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;

}

解释：

void hanoi(int n, char A, char B, char C)：定义一个名为 hanoi 的函数，用于求解汉诺塔问题。该函数接受四个参数：汉诺塔的层数 n，以及三个字符 A、B、C，分别表示三个柱子。

if (n == 1)：如果汉诺塔只有一层，则直接将盘子从起始柱子移动到目标柱子，并输出移动的信息。然后返回。

hanoi(n - 1, A, C, B)：递归调用 hanoi 函数，将前 n-1 个盘子从起始柱子 A 移动到辅助柱子 B 上，以 C 作为中间柱子。输出移动的信息。

printf("Move disk %d from %c to %c\n", n, A, C)：将第 n 个盘子从起始柱子 A 移动到目标柱子 C 上，并输出移动的信息。

hanoi(n - 1, B, A, C)：递归调用 hanoi 函数，将前 n-1 个盘子从辅助柱子 B 移动到目标柱子 C 上，以 A 作为中间柱子。输出移动的信息。

int main()：程序的主函数。首先提示用户输入汉诺塔的层数，并读入该值。然后调用 hanoi 函数求解汉诺塔问题。

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

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

#include <stdio.h>

#include <stdlib.h>

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;

}

解释：

maxSubArray函数用于求解最大子序和。它接受一个整数数组nums和数组的大小numsSize作为参数。

在函数中，我们使用两个变量max_so_far和curr_max来记录最大子序和。max_so_far用于记录已经找到的最大子序和，而curr_max则用于记录当前的最大子序和。

我们使用一个循环遍历整个数组。对于每个元素，我们将其与curr_max相加，并检查结果是否比当前的最大子序和大。如果是，则更新curr_max为两者之和；否则，将curr_max设置为该元素的值。然后，我们比较max_so_far和curr_max的值，并将较大的值赋给max_so_far。

最后，我们返回max_so_far作为结果。

在主函数中，我们定义了一个整数数组nums，并将其传递给maxSubArray函数进行求解。然后，我们输出最大子序和的结果。

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

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

下面以Kruskal算法：

#include <stdio.h>

#include <stdlib.h>

// 定义边的结构体

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;

}