【皮皮灰】C语言编程题必会60题

教育 2024-12-18 10:02 广西

【皮皮灰】C语言编程题必会60题

一、基础语法与控制结构

编写一个程序，输出 “Hello, World!”。
输入两个整数，输出它们的和、差、积、商。
编写一个程序，判断一个整数是奇数还是偶数。
输入一个正整数，计算并输出它的阶乘。
打印 1 到 100 之间的所有奇数。
输出 100 以内能被 3 和 5 同时整除的数。
输入一个整数，判断它是否是素数。
计算 1 + 1/2 + 1/3 +... + 1/n 的和，n 由用户输入。
打印九九乘法表。
输入一个正整数，判断它是否是完全平方数。
【牛顿迭代法计算】
以求解方程 f(x) = x^2 - 2（即求 sqrt(2) 的近似值为例），牛顿迭代法的基本公式为 x(n+1) = x(n) - f(x(n)) / f'(x(n))，对于此方程 f'(x) = 2x。

1. 输出 “Hello, World!”
#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

2. 输入两个整数，输出它们的和、差、积、商
#include <stdio.h>

int main() {
    int num1, num2;
    printf("请输入两个整数：\n");
    scanf("%d %d", &num1, &num2);

    printf("和：%d\n", num1 + num2);
    printf("差：%d\n", num1 - num2);
    printf("积：%d\n", num1 * num2);
    // 注意除数不能为0的情况，这里做简单判断
    if (num2 == 0) {
        printf("商：除数不能为0，无法计算\n");
    } else {
        printf("商：%d\n", num1 / num2);
    }

    return 0;
}

3.判断一个整数是奇数还是偶数

#include <stdio.h>

int main() {
    int num;
    printf("请输入一个整数：\n");
    scanf("%d", &num);

    if (num % 2 == 0) {
        printf("%d 是偶数\n", num);
    } else {
        printf("%d 是奇数\n", num);
    }

    return 0;
}

4. 输入一个正整数，计算并输出它的阶乘

#include <stdio.h>

int main() {
    int num;
    long long factorial = 1;  // 用long long类型防止阶乘结果溢出
    printf("请输入一个正整数：\n");
    scanf("%d", &num);

    for (int i = 1; i <= num; i++) {
        factorial *= i;
    }

    printf("%d 的阶乘是 %lld\n", num, factorial);
    return 0;
}

5. 打印 1 到 100 之间的所有奇数

#include <stdio.h>

int main() {
    printf("1到100之间的奇数：\n");
    for (int i = 1; i <= 100; i += 2) {
        printf("%d ", i);
    }
    printf("\n");
    return 0;
}

6. 输出 100 以内能被 3 和 5 同时整除的数

#include <stdio.h>

int main() {
    printf("100以内能被3和5同时整除的数：\n");
    for (int i = 1; i < 100; i++) {
        if (i % 3 == 0 && i % 5 == 0) {
            printf("%d ", i);
        }
    }
    printf("\n");
    return 0;
}

7. 输入一个整数，判断它是否是素数

#include <stdio.h>

int main() {
    int num, i;
    printf("请输入一个整数：\n");
    scanf("%d", &num);

    if (num < 2) {
        printf("%d 不是素数\n", num);
        return 0;
    }

    for (i = 2; i * i <= num; i++) {
        if (num % i == 0) {
            printf("%d 不是素数\n", num);
            return 0;
        }
    }
    printf("%d 是素数\n", num);

    return 0;
}

8. 计算 1 + 1/2 + 1/3 +... + 1/n 的和，n 由用户输入

#include <stdio.h>

int main() {
    int n;
    double sum = 0;
    printf("请输入n的值：\n");
    scanf("%d", &n);

    for (int i = 1; i <= n; i++) {
        sum += 1.0 / i;
    }

    printf("1 + 1/2 + 1/3 +... + 1/%d 的和是 %.2lf\n", n, sum);
    return 0;
}

9. 打印九九乘法表

#include <stdio.h>

int main() {
    for (int i = 1; i <= 9; i++) {
        for (int j = 1; j <= i; j++) {
            printf("%d * %d = %d\t", j, i, i * j);
        }
        printf("\n");
    }
    return 0;
}

10. 输入一个正整数，判断它是否是完全平方数

#include <stdio.h>

#include <math.h>

int main() {
    int num;
    printf("请输入一个正整数：\n");
    scanf("%d", &num);

    double square_root = sqrt(num);
    if (square_root == (int)square_root) {
        printf("%d 是完全平方数\n", num);
    } else {
        printf("%d 不是完全平方数\n", num);
    }

    return 0;
}

以下是使用 C 语言通过牛顿迭代法来求方程根的示例代码，以求解方程 f(x) = x^2 - 2（即求 sqrt(2) 的近似值为例），牛顿迭代法的基本公式为 x(n+1) = x(n) - f(x(n)) / f'(x(n))，对于此方程 f'(x) = 2x。

#include <stdio.h>
#include <math.h>

// 定义要求解的方程，这里以 x^2 - 2 为例
double equation(double x) {
    return x * x - 2;
}

// 定义方程的导数，这里对于 x^2 - 2 导数为 2x
double derivative(double x) {
    return 2 * x;
}

// 牛顿迭代法函数
double newtonMethod(double initialGuess, double tolerance) {
    double xn = initialGuess;
    double xnPlus1;
    do {
        xnPlus1 = xn - equation(xn) / derivative(xn);
        if (fabs(xnPlus1 - xn) < tolerance) {
            break;
        }
        xn = xnPlus1;
    } while (1);
    return xnPlus1;
}

int main() {
    double initialGuess = 1.0;  // 初始猜测值，可以根据具体情况调整
    double tolerance = 1e-6;    // 精度要求，可按需修改
    double result = newtonMethod(initialGuess, tolerance);
    printf("方程的近似根为: %.6lf\n", result);
    return 0;
}

二、数组与字符串

定义一个包含 10 个整数的数组，初始化并输出数组元素。
找出数组中的最大元素和最小元素。
对一个整数数组进行排序（可以选择冒泡排序、插入排序等）。
输入一个字符串，统计其中字符的个数。
反转一个字符串。
判断两个字符串是否相等。
找出一个字符串中出现次数最多的字符。
删除字符串中的特定字符。
将两个字符串连接起来。
统计一个字符串中单词的个数。

11. 定义一个包含 10 个整数的数组，初始化并输出数组元素

int main() {
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    for (int i = 0; i < 10; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

12. 找出数组中的最大元素和最小元素

#include <stdio.h>

int main() {
    int arr[10] = {5, 3, 9, 1, 7, 2, 8, 4, 6, 0};
    int max = arr[0];
    int 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;
}

3. 使用冒泡排序对一个整数数组进行排序

#include <stdio.h>

// 冒泡排序函数
void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[10] = {5, 3, 9, 1, 7, 2, 8, 4, 6, 0};
    bubbleSort(arr, 10);
    for (int i = 0; i < 10; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

14. 输入一个字符串，统计其中字符的个数

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

int main() {
    char str[100];
    printf("请输入一个字符串: ");
    scanf("%s", str);
    int len = strlen(str);
    printf("字符串中字符的个数为: %d\n", len);
    return 0;
}

15. 反转一个字符串

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

void reverseString(char str[]) {
    int len = strlen(str);
    for (int i = 0; i < len / 2; i++) {
        char temp = str[i];
        str[i] = str[len - i - 1];
        str[len - i - 1] = temp;
    }
}

int main() {
    char str[100];
    printf("请输入一个字符串: ");
    scanf("%s", str);
    reverseString(str);
    printf("反转后的字符串: %s\n", str);
    return 0;
}

16. 判断两个字符串是否相等

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

int areEqual(char str1[], char str2[]) {
    return strcmp(str1, str2) == 0;
}

int main() {
    char str1[100], str2[100];
    printf("请输入第一个字符串: ");
    scanf("%s", str1);
    printf("请输入第二个字符串: ");
    scanf("%s", str2);
    if (areEqual(str1, str2)) {
        printf("两个字符串相等\n");
    } else {
        printf("两个字符串不相等\n");
    }
    return 0;
}

17. 找出一个字符串中出现次数最多的字符

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

char mostFrequentChar(char str[]) {
    int len = strlen(str);
    int count[256] = {0};  // 假设ASCII码字符范围，用于统计每个字符出现次数
    for (int i = 0; i < len; i++) {
        count[(int)str[i]]++;
    }
    char maxChar = str[0];
    int maxCount = count[(int)str[0]];
    for (int i = 1; i < len; i++) {
        if (count[(int)str[i]] > maxCount) {
            maxCount = count[(int)str[i]];
            maxChar = str[i];
        }
    }
    return maxChar;
}

int main() {
    char str[100];
    printf("请输入一个字符串: ");
    scanf("%s", str);
    char result = mostFrequentChar(str);
    printf("出现次数最多的字符是: %c\n", result);
    return 0;
}

18. 删除字符串中的特定字符

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

void removeChar(char str[], char target) {
    int len = strlen(str);
    int j = 0;
    for (int i = 0; i < len; i++) {
        if (str[i]!= target) {
            str[j++] = str[i];
        }
    }
    str[j] = '\0';
}

int main() {
    char str[100];
    char target;
    printf("请输入一个字符串: ");
    scanf("%s", str);
    printf("请输入要删除的特定字符: ");
    scanf(" %c", &target);  // 注意这里要加空格，避免接收缓冲区残留的换行符等
    removeChar(str, target);
    printf("删除特定字符后的字符串: %s\n", str);
    return 0;
}

19. 将两个字符串连接起来

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

void concatenateStrings(char str1[], char str2[]) {
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    for (int i = 0; i < len2; i++) {
        str1[len1 + i] = str2[i];
    }
    str1[len1 + len2] = '\0';
}

int main() {
    char str1[100], str2[100];
    printf("请输入第一个字符串: ");
    scanf("%s", str1);
    printf("请输入第二个字符串: ");
    scanf("%s", str2);
    concatenateStrings(str1, str2);
    printf("连接后的字符串: %s\n", str1);
    return 0;
}

20. 统计一个字符串中单词的个数

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

int countWords(char str[]) {
    int count = 0;
    int len = strlen(str);
    int i = 0;
    while (i < len) {
        while (str[i] == ' ') {  // 跳过空格
            i++;
        }
        if (str[i]!= '\0') {
            count++;
            while (str[i]!= ' ' && str[i]!= '\0') {  // 跳过单词内字符
                i++;
            }
        }
    }
    return count;
}

int main() {
    char str[100];
    printf("请输入一个字符串: ");
    scanf("%s", str);
    int result = countWords(str);
    printf("字符串中单词的个数为: %d\n", result);
    return 0;
}

三、函数

编写一个函数，计算两个整数的最大公约数。
实现一个函数，判断一个整数是否是回文数。
写一个函数，计算一个整数的各位数字之和。
设计一个函数，将一个整数转换为二进制字符串并返回。
编写一个函数，实现两个整数的交换（不使用临时变量）。
定义一个函数，判断一个字符串是否是回文字符串。
写一个函数，计算一个浮点数的平方根。
实现一个函数，将一个字符串中的大写字母转换为小写字母，小写字母转换为大写字母。
设计一个函数，统计一个字符串中特定字符的出现次数。
编写一个函数，判断一个整数数组是否是有序的（升序或降序）。

21. 计算两个整数的最大公约数（使用辗转相除法）

#include <stdio.h>

int greatest_common_divisor(int a, int b) {
    while (b!= 0) {
        int temp = a % b;
        a = b;
        b = temp;
    }
    return a;
}

22. 判断一个整数是否是回文数

#include <stdio.h>

int is_palindrome_num(int n) {
    int original = n;
    int reversed = 0;
    while (n > 0) {
        reversed = reversed * 10 + n % 10;
        n /= 10;
    }
    return original == reversed;
}

23. 计算一个整数的各位数字之和

#include <stdio.h>

int sum_of_digits(int num) {
    int sum = 0;
    int temp = num < 0? -num : num;
    while (temp > 0) {
        sum += temp % 10;
        temp /= 10;
    }
    return sum;
}

24. 将一个整数转换为二进制字符串并返回（这里简单返回一个用数组表示的二进制结果，暂不考虑真正类似字符串那样的动态内存分配等复杂情况用于示意）

#include <stdio.h>

void int_to_binary_str(int n, char binary_str[]) {
    int index = 0;
    int temp = n;
    while (temp > 0) {
        binary_str[index++] = (temp % 2) + '0';
        temp /= 2;
    }
    binary_str[index] = '\0';
    // 反转字符串使其顺序正确
    int left = 0;
    int right = index - 1;
    while (left < right) {
        char t = binary_str[left];
        binary_str[left] = binary_str[right];
        binary_str[right] = t;
        left++;
        right--;
    }
}

25. 实现两个整数的交换（不使用临时变量）

#include <stdio.h>

void swap_numbers(int *a, int *b) {
    *a = *a + *b;
    *b = *a - *b;
    *a = *a - *b;
}

26. 判断一个字符串是否是回文字符串.

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

int is_palindrome_str(char s[]) {
    int len = strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i]!= s[len - i - 1]) {
            return 0;
        }
    }
    return 1;
}

27. 计算一个浮点数的平方根（调用数学库函数实现）

#include <stdio.h>
#include <math.h>

double square_root(double num) {
    return sqrt(num);
} 牛顿迭代法

28. 将一个字符串中的大写字母转换为小写字母，小写字母转换为大写字母

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

void swap_case(char s[]) {
    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        if (s[i] >= 'A' && s[i] <= 'Z') {
            s[i] += 32;
        } else if (s[i] >= 'a' && s[i] <= 'e') {
            s[i] -= 32;
        }
    }
}

29. 统计一个字符串中特定字符的出现次数

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

int count_char(char s[], char target_char) {
    int count = 0;
    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        if (s[i] == target_char) {
            count++;
        }
    }
    return count;
}

30. 判断一个整数数组是否是有序的（升序或降序）

#include <stdio.h>
#include <stdbool.h>

bool is_ordered(int arr[], int size) {
    bool ascending = true;
    bool descending = true;
    for (int i = 0; i < size - 1; i++) {
        if (arr[i] > arr[i + 1]) {
            ascending = false;
        }
        if (arr[i] < arr[i + 1]) {
            descending = false;
        }
    }
    return ascending || descending;
}

四、指针

定义一个指针变量，指向一个整数，并输出该整数的值。
使用指针实现两个整数的交换。
通过指针访问数组元素，输出数组中的所有元素。
编写一个程序，使用指针遍历一个字符串并输出每个字符。
定义一个指针数组，指向多个字符串，输出这些字符串。
使用指针实现对一个整数数组的排序。
通过指针操作，将一个字符串复制到另一个字符串。
定义一个函数，接收一个指针参数，修改指针所指向的值。
使用指针实现对一个结构体的访问和修改。
编写一个程序，使用指针动态分配内存，存储一个整数数组，并输出数组元素。

31. 定义一个指针变量，指向一个整数，并输出该整数的值

#include <stdio.h>

int main() {
    int num = 10;
    int *ptr = &num;  // 定义指针变量ptr，指向整数num
    printf("整数的值为：%d\n", *ptr);  // 通过解引用指针输出所指整数的值
    return 0;
}

32. 使用指针实现两个整数的交换

#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int num1 = 3, num2 = 5;
    int *ptr1 = &num1, *ptr2 = &num2;
    swap(ptr1, ptr2);
    printf("交换后：num1 = %d, num2 = %d\n", num1, num2);
    return 0;
}

33. 通过指针访问数组元素，输出数组中的所有元素

#include <stdio.h>

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int *ptr = arr;  // 指针指向数组首地址
    for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
        printf("%d ", *(ptr + i));  // 通过指针偏移访问数组元素并输出
    }
    printf("\n");
    return 0;
}

34. 编写一个程序，使用指针遍历一个字符串并输出每个字符

#include <stdio.h>

int main() {
    char str[] = "Hello";
    char *ptr = str;
    while (*ptr!= '\0') {
        printf("%c", *ptr);
        ptr++;
    }
    printf("\n");
    return 0;
}

35. 定义一个指针数组，指向多个字符串，输出这些字符串

#include <stdio.h>

int main() {
    char *strArr[] = {"Hello", "World", "C Language"};
    for (int i = 0; i < 3; i++) {
        printf("%s\n", strArr[i]);
    }
    return 0;
}

36. 使用指针实现对一个整数数组的排序（这里以简单的冒泡排序为例）

#include <stdio.h>

void bubbleSort(int *arr, int size) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (*(arr + j) > *(arr + j + 1)) {
                int temp = *(arr + j);
                *(arr + j) = *(arr + j + 1);
                *(arr + j + 1) = temp;
            }
        }
    }
}

int main() {
    int arr[] = {5, 3, 4, 1, 2};
    int size = sizeof(arr) / sizeof(arr[0]);
    int *ptr = arr;
    bubbleSort(ptr, size);
    for (int i = 0; i < size; i++) {
        printf("%d ", *(ptr + i));
    }
    printf("\n");
    return 0;
}

37. 通过指针操作，将一个字符串复制到另一个字符串

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

void strCopy(char *dest, const char *src) {
    while ((*dest++ = *src++)!= '\0') {
        ;
    }
}

int main() {
    char src[] = "Hello";
    char dest[20];
    char *ptr_dest = dest;
    char *ptr_src = src;
    strCopy(ptr_dest, ptr_src);
    printf("复制后的字符串：%s\n", dest);
    return 0;
}

38. 定义一个函数，接收一个指针参数，修改指针所指向的值

#include <stdio.h>

void modifyValue(int *ptr) {
    *ptr = 100;
}

int main() {
    int num = 10;
    int *ptr = &num;
    modifyValue(ptr);
    printf("修改后的值：%d\n", num);
    return 0;
}

39. 使用指针实现对一个结构体的访问和修改（以下以简单结构体示例）

#include <stdio.h>

// 定义结构体
struct Student {
    char name[20];
    int age;
};

void modifyStudent(struct Student *stu) {
    strcpy(stu->name, "Tom");
    stu->age = 20;
}

int main() {
    struct Student s = {"Alice", 18};
    struct Student *ptr = &s;
    modifyStudent(ptr);
    printf("姓名：%s，年龄：%d\n", ptr->name, ptr->age);
    return 0;
}

40. 编写一个程序，使用指针动态分配内存，存储一个整数数组，并输出数组元素

#include <stdio.h>
#include <stdlib.h>

int main() {
    int size;
    printf("请输入数组大小：");
    scanf("%d", &size);
    int *arr = (int *)malloc(size * sizeof(int));  // 动态分配内存
    if (arr == NULL) {
        printf("内存分配失败！\n");
        return -1;
    }
    for (int i = 0; i < size; i++) {
        arr[i] = i + 1;
    }
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    free(arr);  // 释放动态分配的内存
    printf("\n");
    return 0;
}

五、结构体与联合体

定义一个结构体表示学生信息（包括姓名、年龄、成绩），并初始化一个学生对象并输出其信息。
编写一个程序，使用结构体存储多个学生的信息，并输出所有学生的平均成绩。
定义一个联合体，包含一个整数和一个浮点数，根据用户输入选择存储的数据类型并输出。
使用结构体实现链表数据结构，包括插入节点、删除节点和输出链表的功能。
定义一个结构体表示日期（年、月、日），编写函数实现日期的比较。
创建一个结构体数组，存储多个员工信息（姓名、工资、部门），并按照工资进行排序。
使用联合体存储不同类型的数据，根据用户输入选择存储的数据类型并进行相应的操作。
定义一个结构体表示矩形，编写函数计算矩形的面积和周长。
使用结构体表示二叉树节点，实现二叉树的插入和遍历操作。
定义一个结构体表示复数，实现复数的加法、减法和乘法运算。

41.定义一个结构体表示学生信息（包括姓名、年龄、成绩），并初始化一个学生对象并输出其信息

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

// 定义学生结构体
struct Student {
    char name[20];
    int age;
    float score;
};

int main() {
    // 初始化一个学生对象
    struct Student stu = {"Tom", 18, 85.5};
    // 输出学生信息
    printf("姓名：%s\n", stu.name);
    printf("年龄：%d\n", stu.age);
    printf("成绩：%.1f\n", stu.score);
    return 0;
}

42. 编写一个程序，使用结构体存储多个学生的信息，并输出所有学生的平均成绩

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

// 定义学生结构体
struct Student {
    char name[20];
    int age;
    float score;
};

int main() {
    struct Student students[3];  // 假设存储3个学生信息

    // 输入学生信息
    for (int i = 0; i < 3; i++) {
        printf("请输入第%d个学生的姓名、年龄、成绩：\n", i + 1);
        scanf("%s %d %f", students[i].name, &students[i].age, &students[i].score);
    }

    float sum = 0;
    for (int i = 0; i < 3; i++) {
        sum += students[i].score;
    }

    // 计算并输出平均成绩
    printf("平均成绩：%.2f\n", sum / 3);
    return 0;
}

43. 定义一个联合体，包含一个整数和一个浮点数，根据用户输入选择存储的数据类型并输出

#include <stdio.h>

// 定义联合体
union Data {
    int num;
    float fnum;
};

int main() {
    union Data data;
    int choice;
    printf("请选择存储的数据类型（1表示整数，2表示浮点数）：");
    scanf("%d", &choice);

    if (choice == 1) {
        printf("请输入一个整数：");
        scanf("%d", &data.num);
        printf("存储的整数为：%d\n", data.num);
    } else if (choice == 2) {
        printf("请输入一个浮点数：");
        scanf("%f", &data.fnum);
        printf("存储的浮点数为：%f\n", data.fnum);
    } else {
        printf("无效的选择！\n");
    }

    return 0;
}

44. 使用结构体实现链表数据结构，包括插入节点、删除节点和输出链表的功能

#include <stdio.h>
#include <stdlib.h>

// 定义链表节点结构体
struct ListNode {
    int data;
    struct ListNode *next;
};

// 在链表头部插入节点
void insertAtHead(struct ListNode **head, int value) {
    struct ListNode *newNode = (struct ListNode *)malloc(sizeof(struct ListNode));
    newNode->data = value;
    newNode->next = *head;
    *head = newNode;
}

// 删除链表中值为value的节点
void deleteNode(struct ListNode **head, int value) {
    if (*head == NULL) return;
    if ((*head)->data == value) {
        struct ListNode *temp = *head;
        *head = (*head)->next;
        free(temp);
        return;
    }
    struct ListNode *curr = *head;
    while (curr->next!= NULL && curr->next->data!= value) {
        curr = curr->next;
    }
    if (curr->next!= NULL) {
        struct ListNode *temp = curr->next;
        curr->next = curr->next->next;
        free(temp);
    }
}

// 输出链表
void printList(struct ListNode *head) {
    struct ListNode *curr = head;
    while (curr!= NULL) {
        printf("%d ", curr->data);
        curr = curr->next;
    }
    printf("\n");
}

int main() {
    struct ListNode *head = NULL;
    insertAtHead(&head, 3);
    insertAtHead(&head, 2);
    insertAtHead(&head, 1);
    printList(head);
    deleteNode(&head, 2);
    printList(head);
    return 0;
}

45. 定义一个结构体表示日期（年、月、日），编写函数实现日期的比较

#include <stdio.h>

// 定义日期结构体
struct Date {
    int year;
    int month;
    int day;
};

// 比较两个日期大小，返回值：1表示date1大于date2，-1表示date1小于date2，0表示相等
int compareDates(struct Date date1, struct Date date2) {
    if (date1.year > date2.year) return 1;
    if (date1.year < date2.year) return -1;
    if (date1.month > date2.month) return 1;
    if (date1.month < date2.month) return -1;
    if (date1.day > date2.day) return 1;
    if (date1.day < date2.day) return -1;
    return 0;
}

int main() {
    struct Date date1 = {2024, 12, 10};
    struct Date date2 = {2024, 12, 13};
    int result = compareDates(date1, date2);
    if (result == 1) {
        printf("date1大于date2\n");
    } else if (result == -1) {
        printf("date1小于date2\n");
    } else {
        printf("date1等于date2\n");
    }
    return 0;
}

46. 创建一个结构体数组，存储多个员工信息（姓名、工资、部门），并按照工资进行排序（这里以简单的冒泡排序为例）

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

// 定义员工结构体
struct Employee {
    char name[20];
    float salary;
    char department[20];
};

// 交换两个员工结构体
void swapEmployees(struct Employee *a, struct Employee *b) {
    struct Employee temp = *a;
    *a = *b;
    *b = temp;
}

// 按照工资对员工结构体数组进行排序
void sortEmployeesBySalary(struct Employee employees[], int size) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (employees[j].salary > employees[j + 1].salary) {
                swapEmployees(&employees[j], &employees[j + 1]);
            }
        }
    }
}

int main() {
    struct Employee employees[3];

    // 输入员工信息
    for (int i = 0; i < 3; i++) {
        printf("请输入第%d个员工的姓名、工资、部门：\n", i + 1);
        scanf("%s %f %s", employees[i].name, &employees[i].salary, &employees[i].department);
    }

    sortEmployeesBySalary(employees, 3);

    // 输出排序后的员工信息
    for (int i = 0; i < 3; i++) {
        printf("姓名：%s，工资：%.2f，部门：%s\n", employees[i].name, employees[i].salary, employees[i].department);
    }
    return 0;
}

47. 使用联合体存储不同类型的数据，根据用户输入选择存储的数据类型并进行相应的操作（示例中进行简单的算术运算，整数相加，浮点数相乘）

#include <stdio.h>

// 定义联合体
union Data {
    int num;
    float fnum;
};

int main() {
    union Data data;
    int choice;
    printf("请选择存储的数据类型（1表示整数，2表示浮点数）：");
    scanf("%d", &choice);

    if (choice == 1) {
        printf("请输入第一个整数：");
        scanf("%d", &data.num);
        int num2;
        printf("请输入第二个整数：");
        scanf("%d", &num2);
        printf("两数相加结果：%d\n", data.num + num2);
    } else if (choice == 2) {
        printf("请输入第一个浮点数：");
        scanf("%f", &data.fnum);
        float fnum2;
        printf("请输入第二个浮点数：");
        scanf("%f", &fnum2);
        printf("两数相乘结果：%f\n", data.fnum * fnum2);
    } else {
        printf("无效的选择！\n");
    }

    return 0;
}

48. 定义一个结构体表示矩形，编写函数计算矩形的面积和周长

#include <stdio.h>

// 定义矩形结构体
struct Rectangle {
    float length;
    float width;
};

// 计算矩形面积
float calculateArea(struct Rectangle rect) {
    return rect.length * rect.width;
}

// 计算矩形周长
float calculatePerimeter(struct Rectangle rect) {
    return 2 * (rect.length + rect.width);
}

int main() {
    struct Rectangle rect = {5.0, 3.0};
    printf("矩形面积：%.2f\n", calculateArea(rect));
    printf("矩形周长：%.2f\n", calculatePerimeter(rect));
    return 0;
}

49. 使用结构体表示二叉树节点，实现二叉树的插入和遍历操作（以下是简单的二叉搜索树示例，实现中序遍历）

50. 定义一个结构体表示复数，实现复数的加法、减法和乘法运算

六、文件操作

创建一个文本文件，并向其中写入一些文本内容。
读取一个文本文件的内容并输出到屏幕上。
统计一个文本文件中特定字符出现的次数。
将一个文本文件的内容复制到另一个文本文件中。
读取一个包含整数的文本文件，计算这些整数的和并输出。
创建一个二进制文件，写入一些整数数据，然后读取并输出这些数据。
在一个文本文件中查找特定的字符串，如果找到则输出其位置。
实现一个函数，将多个文本文件合并为一个文件。
读取一个文本文件，将其中的所有字母转换为大写并写入另一个文件。
统计一个文本文件中的行数和单词数。

51.创建一个文本文件，并向其中写入一些文本内容

#include <stdio.h>
#include <stdlib.h>

int main() {
    FILE *fp;
    fp = fopen("test.txt", "w");  // 以写入模式打开文件，如果不存在则创建
    if (fp == NULL) {
        perror("打开文件失败");
        return -1;
    }
    char content[] = "这是一段示例文本内容。\n用于测试文件写入操作。";
    fputs(content, fp);  // 将内容写入文件
    fclose(fp);  // 关闭文件
    return 0;
}

53. 统计一个文本文件中特定字符出现的次数

int count_specific_char(const char *filename, char target_char) {
    FILE *fp;
    fp = fopen(filename, "r");
    if (fp == NULL) {
        perror("打开文件失败");
        return -1;
    }
    int count = 0;
    char ch;
    while ((ch = fgetc(fp))!= EOF) {
        if (ch == target_char) {
            count++;
        }
    }
    fclose(fp);
    return count;
}

int main() {
    char target_char = '是';
    int result = count_specific_char("test.txt", target_char);
    if (result!= -1) {
        printf("字符 '%c' 在文件中出现的次数为：%d\n", target_char, result);
    }
    return 0;
}

59. 读取一个文本文件，将其中的所有字母转换为大写并写入另一个文件

#include <stdio.h>
#include <stdlib.h>

int convert_to_uppercase(const char *source_file, const char *destination_file) {
    FILE *source_fp, *destination_fp;
    source_fp = fopen(source_file, "r");
    if (source_fp == NULL) {
        perror("打开源文件失败");
        return -1;
    }
    destination_fp = fopen(destination_file, "w");
    if (destination_fp == NULL) {
        perror("打开目标文件失败");
        fclose(source_fp);
        return -1;
    }
    char ch;
    while ((ch = fgetc(source_fp))!= EOF) {
        if (ch >= 'a' && ch <= 'z') {
            ch -= 32;
        }
        fputc(ch, destination_fp);
    }
    fclose(source_fp);
    fclose(destination_fp);
    return 0;
}

int main() {
    int result = convert_to_uppercase("test.txt", "uppercase.txt");
    if (result == 0) {
        printf("转换并写入文件成功！\n");
    } else {
        printf("操作失败！\n");
    }
    return 0;
}

60. 统计一个文本文件中的行数和单词数

#include <stdio.h>
#include <stdlib.h>

int count_lines_and_words(const char *filename) {
    FILE *fp;
    fp = fopen(filename, "r");
    if (fp == NULL) {
        perror("打开文件失败");
        return -1;
    }
    int lines = 0;
    int words = 0;
    int in_word = 0;
    char ch;
    while ((ch = fgetc(fp))!= EOF) {
        if (ch == '\n') {
            lines++;
        }
        if (ch =='' || ch == '\t' || ch == '\n') {
            in_word = 0;
        } else if (in_word == 0) {
            in_word = 1;
            words++;
        }
    }
    fclose(fp);
    printf("文件中的行数为：%d，单词数为：%d\n", lines, words);
    return 0;
}

int main() {
    count_lines_and_words("test.txt");
    return 0;
}

【皮皮灰免费一对一咨询】

灰灰考研

最全的【计算机考研】【软件考研】考研信息！最丰富的共享资料！最大程度上帮助学渣狗登上研究生大门！