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;
}
解释：
#include
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
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
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
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
#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;
}
解释：
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
#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;
}