通过实践学编程：20道C语言练习题助力学生编程技能提升专升本期末考试，数据结构

太过爱你忘了你带给我的痛 2023-10-14 17:12 12阅读 0赞

当学生和考生投身于编程的学习之旅时，实践和挑战往往是提升技能的关键。在这篇博客中，我们将带您探索一系列激发兴趣和提升编程技能的C语言练习题。通过实际动手操作，您将会收获更多，提高您的编程熟练度。

### 学以致用：20道C语言练习题助力学生编程技能提升 ###

在编程的世界里，实际动手操作往往比理论知识更能够帮助我们真正掌握技能。因此，我们准备了一系列适用于学生和考生的C语言练习题，通过解决这些挑战，您将能够深入理解编程的精髓，提升自己的编程技能。

#### 1. 掌握基础：10道入门级练习题 ####

我们从一些基础的练习题开始，让您熟悉C语言的基本语法和数据结构。这些题目涵盖了数组、循环、条件语句等基本概念，帮助您建立坚实的编程基础。

#### 2. 挑战自我：5道中级练习题 ####

在掌握了基础知识后，我们提供了一些稍微有难度的练习题，让您深入挖掘C语言的特性。这些题目涵盖了递归、字符串处理、排序算法等内容，帮助您提升解决问题的能力。

#### 3. 探索更深：5道高级练习题 ####

对于那些渴望挑战更高水平的学生和考生，我们准备了一些高级练习题。这些题目要求您思维更为灵活，能够将多个概念结合起来解决复杂问题，从而更好地理解编程的本质。

#### 如何使用这些练习题？ ####

1.  **逐个挑战**：从基础到高级，逐步挑战这些练习题，不断提升自己的编程能力。
2.  **实践是关键**：不要只停留在理论，务必亲自动手操作，亲自编写代码。只有通过实际操作，才能真正理解和掌握编程。
3.  **查阅文档**：在解决问题时，如果遇到不熟悉的函数或概念，不要犹豫查阅官方文档或编程书籍。
4.  **理解解答**：在完成练习后，仔细阅读我们提供的答案，比较自己的解答与标准答案的差异，从中学习和改进。

#### 结语 ####

学习编程是一项持久的旅程，而这些C语言练习题将会是您的良师益友。通过实际操作，您将在不断的挑战中不断成长，提升自己的编程技能。无论您是刚刚踏入编程的世界，还是已经有一些基础，这些练习题都能帮助您迈向更高的水平。开始吧，让我们一起在编程的海洋中航行！

**题目1：** 编写一个程序，计算并输出 1 到 100 的所有整数的和。

**答案1：**

#include <stdio.h>
    
    int main() {
        
        int sum = 0;
        for (int i = 1; i <= 100; ++i) {
        
            sum += i;
        }
        printf("Sum: %d\n", sum);
        return 0;
    }

**题目2：** 编写一个函数，接受一个整数参数 n，然后计算并返回 n 的阶乘。

**答案2：**

#include <stdio.h>
    
    int factorial(int n) {
        
        if (n == 0 || n == 1) {
        
            return 1;
        }
        return n * factorial(n - 1);
    }
    
    int main() {
        
        int n = 5;
        printf("Factorial of %d: %d\n", n, factorial(n));
        return 0;
    }

**题目3：** 编写一个函数，接受一个整数参数 n，然后生成一个 n × n 的单位矩阵（对角线上元素为 1，其他为 0）。

**答案3：**

#include <stdio.h>
    
    void printIdentityMatrix(int n) {
        
        for (int i = 0; i < n; ++i) {
        
            for (int j = 0; j < n; ++j) {
        
                if (i == j) {
        
                    printf("1 ");
                } else {
        
                    printf("0 ");
                }
            }
            printf("\n");
        }
    }
    
    int main() {
        
        int n = 4;
        printIdentityMatrix(n);
        return 0;
    }

**题目4：** 编写一个程序，从文件中读取一篇文章，统计其中每个单词出现的次数。

**答案4：**

#include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    #define MAX_WORD_LENGTH 50
    
    int main() {
        
        char filename[] = "sample.txt";
        FILE *file = fopen(filename, "r");
        if (file == NULL) {
        
            printf("Error opening file.\n");
            return 1;
        }
    
        char word[MAX_WORD_LENGTH];
        int wordCount = 0;
        while (fscanf(file, "%s", word) != EOF) {
        
            wordCount++;
        }
    
        printf("Total words in the file: %d\n", wordCount);
    
        fclose(file);
        return 0;
    }

**题目5：** 编写一个函数，接受一个字符串参数，然后返回该字符串的逆序字符串。

**答案5：**

#include <stdio.h>
    #include <string.h>
    
    void reverseString(char *str) {
        
        int length = strlen(str);
        for (int i = 0; i < length / 2; ++i) {
        
            char temp = str[i];
            str[i] = str[length - i - 1];
            str[length - i - 1] = temp;
        }
    }
    
    int main() {
        
        char str[] = "programming";
        reverseString(str);
        printf("Reversed string: %s\n", str);
        return 0;
    }

**题目6：** 实现一个简单的链表数据结构，包括添加节点、删除节点和打印链表等基本操作。

**答案6：**

#include <stdio.h>
    #include <stdlib.h>
    
    struct Node {
        
        int data;
        struct Node *next;
    };
    
    void printList(struct Node *head) {
        
        struct Node *current = head;
        while (current != NULL) {
        
            printf("%d ", current->data);
            current = current->next;
        }
        printf("\n");
    }
    
    void insertNode(struct Node **head, int data) {
        
        struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
        newNode->data = data;
        newNode->next = *head;
        *head = newNode;
    }
    
    void deleteNode(struct Node **head, int data) {
        
        if (*head == NULL) {
        
            return;
        }
        if ((*head)->data == data) {
        
            struct Node *temp = *head;
            *head = (*head)->next;
            free(temp);
            return;
        }
        struct Node *prev = *head;
        struct Node *current = (*head)->next;
        while (current != NULL && current->data != data) {
        
            prev = current;
            current = current->next;
        }
        if (current == NULL) {
        
            return;
        }
        prev->next = current->next;
        free(current);
    }
    
    int main() {
        
        struct Node *head = NULL;
        insertNode(&head, 3);
        insertNode(&head, 7);
        insertNode(&head, 10);
    
        printf("Original list: ");
        printList(head);
    
        deleteNode(&head, 7);
    
        printf("List after deleting 7: ");
        printList(head);
    
        return 0;
    }

**题目7：** 编写一个程序，模拟实现生产者-消费者问题，使用线程进行生产和消费。

**答案7：**

#include <stdio.h>
    #include <stdlib.h>
    #include <pthread.h>
    
    #define BUFFER_SIZE 5
    #define ITEMS_TO_PRODUCE 10
    
    int buffer[BUFFER_SIZE];
    int itemCount = 0;
    
    pthread_mutex_t bufferMutex = PTHREAD_MUTEX_INITIALIZER;
    pthread_cond_t canProduce = PTHREAD_COND_INITIALIZER;
    pthread_cond_t canConsume = PTHREAD_COND_INITIALIZER;
    
    void *producer(void *arg) {
        
        for (int i = 0; i < ITEMS_TO_PRODUCE; ++i) {
        
            pthread_mutex_lock(&bufferMutex);
            while (itemCount == BUFFER_SIZE) {
        
                pthread_cond_wait(&canProduce, &bufferMutex);
            }
            buffer[itemCount++] = i;
            pthread_cond_signal(&canConsume);
            pthread_mutex_unlock(&bufferMutex);
        }
        pthread_exit(NULL);
    }
    
    void *consumer(void *arg) {
        
        for (int i = 0; i < ITEMS_TO_PRODUCE; ++i) {
        
            pthread_mutex_lock(&bufferMutex);
            while (itemCount == 0) {
        
                pthread_cond_wait(&canConsume, &bufferMutex);
            }
            int item = buffer[--itemCount];
            printf("Consumed: %d\n", item);
            pthread_cond_signal(&canProduce);
            pthread_mutex_unlock(&bufferMutex);
        }
        pthread_exit(NULL);
    }
    
    int main() {
        
        pthread_t producerThread, consumerThread;
    
        pthread_create(&producerThread, NULL, producer, NULL);
        pthread_create(&consumerThread, NULL, consumer, NULL);
    
        pthread_join(producerThread, NULL);
        pthread_join
    
    (consumerThread, NULL);
    
        return 0;
    }

**题目8：** 编写一个函数，接受一个整数数组和数组长度，然后返回数组中的所有素数。

**答案8：**

#include <stdio.h>
    #include <stdbool.h>
    
    bool isPrime(int num) {
        
        if (num <= 1) {
        
            return false;
        }
        for (int i = 2; i * i <= num; ++i) {
        
            if (num % i == 0) {
        
                return false;
            }
        }
        return true;
    }
    
    void printPrimes(int arr[], int size) {
        
        printf("Prime numbers in the array: ");
        for (int i = 0; i < size; ++i) {
        
            if (isPrime(arr[i])) {
        
                printf("%d ", arr[i]);
            }
        }
        printf("\n");
    }
    
    int main() {
        
        int arr[] = {
        2, 4, 7, 10, 11, 15, 17};
        int size = sizeof(arr) / sizeof(arr[0]);
        printPrimes(arr, size);
        return 0;
    }

**题目9：** 编写一个程序，实现一个简单的图书管理系统，包括添加书籍、查找书籍、借阅和归还书籍等功能。

**答案9：**

#include <stdio.h>
    #include <stdbool.h>
    #include <string.h>
    
    struct Book {
        
        int id;
        char title[100];
        char author[100];
        bool isAvailable;
    };
    
    void addBook(struct Book *library, int *bookCount, const char *title, const char *author) {
        
        struct Book newBook;
        newBook.id = *bookCount + 1;
        strcpy(newBook.title, title);
        strcpy(newBook.author, author);
        newBook.isAvailable = true;
    
        library[*bookCount] = newBook;
        (*bookCount)++;
    }
    
    int findBook(struct Book *library, int bookCount, const char *title) {
        
        for (int i = 0; i < bookCount; ++i) {
        
            if (strcmp(library[i].title, title) == 0) {
        
                return i;
            }
        }
        return -1;
    }
    
    void borrowBook(struct Book *library, int bookIndex) {
        
        if (bookIndex != -1 && library[bookIndex].isAvailable) {
        
            library[bookIndex].isAvailable = false;
            printf("Book \"%s\" has been borrowed.\n", library[bookIndex].title);
        } else {
        
            printf("Book not available for borrowing.\n");
        }
    }
    
    void returnBook(struct Book *library, int bookIndex) {
        
        if (bookIndex != -1 && !library[bookIndex].isAvailable) {
        
            library[bookIndex].isAvailable = true;
            printf("Book \"%s\" has been returned.\n", library[bookIndex].title);
        } else {
        
            printf("Invalid book for return.\n");
        }
    }
    
    int main() {
        
        struct Book library[100];
        int bookCount = 0;
    
        addBook(library, &bookCount, "Introduction to Programming", "John Smith");
        addBook(library, &bookCount, "Data Structures and Algorithms", "Jane Doe");
    
        int bookIndex = findBook(library, bookCount, "Introduction to Programming");
        borrowBook(library, bookIndex);
    
        bookIndex = findBook(library, bookCount, "Data Structures and Algorithms");
        returnBook(library, bookIndex);
    
        return 0;
    }

**题目10：** 编写一个函数，接受一个整数参数 n，然后生成一个 n × n 的螺旋矩阵，从 1 到 n^2 依次填入。

**答案10：**

#include <stdio.h>
    
    void generateSpiralMatrix(int n) {
        
        int matrix[n][n];
        int value = 1;
        int top = 0, bottom = n - 1, left = 0, right = n - 1;
    
        while (top <= bottom && left <= right) {
        
            for (int i = left; i <= right; ++i) {
        
                matrix[top][i] = value++;
            }
            top++;
    
            for (int i = top; i <= bottom; ++i) {
        
                matrix[i][right] = value++;
            }
            right--;
    
            if (top <= bottom) {
        
                for (int i = right; i >= left; --i) {
        
                    matrix[bottom][i] = value++;
                }
                bottom--;
            }
    
            if (left <= right) {
        
                for (int i = bottom; i >= top; --i) {
        
                    matrix[i][left] = value++;
                }
                left++;
            }
        }
    
        for (int i = 0; i < n; ++i) {
        
            for (int j = 0; j < n; ++j) {
        
                printf("%2d ", matrix[i][j]);
            }
            printf("\n");
        }
    }
    
    int main() {
        
        int n = 4;
        generateSpiralMatrix(n);
        return 0;
    }

**题目11：** 编写一个函数，接受一个整数参数 n，然后判断 n 是否为回文数（正着读和倒着读都一样）。

**答案11：**

#include <stdio.h>
    #include <stdbool.h>
    
    bool isPalindrome(int n) {
        
        int original = n;
        int reversed = 0;
    
        while (n > 0) {
        
            int digit = n % 10;
            reversed = reversed * 10 + digit;
            n /= 10;
        }
    
        return original == reversed;
    }
    
    int main() {
        
        int num = 12321;
        if (isPalindrome(num)) {
        
            printf("%d is a palindrome.\n", num);
        } else {
        
            printf("%d is not a palindrome.\n", num);
        }
        return 0;
    }

**题目12：** 编写一个函数，接受一个整数数组和数组长度，然后找到数组中的最大值和最小值。

**答案12：**

#include <stdio.h>
    
    void findMinMax(int arr[], int size, int *min, int *max) {
        
        if (size == 0) {
        
            return;
        }
    
        *min = arr[0];
        *max = arr[0];
    
        for (int i = 1; i < size; ++i) {
        
            if (arr[i] < *min) {
        
                *min = arr[i];
            }
            if (arr[i] > *max) {
        
                *max = arr[i];
            }
        }
    }
    
    int main() {
        
        int arr[] = {
        10, 5, 3, 8, 12, 6};
        int size = sizeof(arr) / sizeof(arr[0]);
    
        int min, max;
        findMinMax(arr
    
    , size, &min, &max);
    
        printf("Min: %d\n", min);
        printf("Max: %d\n", max);
    
        return 0;
    }

**题目13：** 编写一个函数，接受一个字符串参数，然后检查该字符串是否是有效的括号表达式。

**答案13：**

#include <stdio.h>
    #include <stdbool.h>
    #include <string.h>
    
    bool isValidParentheses(const char *str) {
        
        int len = strlen(str);
        char stack[len];
        int top = -1;
    
        for (int i = 0; i < len; ++i) {
        
            if (str[i] == '(' || str[i] == '[' || str[i] == '{') {
        
                stack[++top] = str[i];
            } else if (str[i] == ')' && top >= 0 && stack[top] == '(') {
        
                top--;
            } else if (str[i] == ']' && top >= 0 && stack[top] == '[') {
        
                top--;
            } else if (str[i] == '}' && top >= 0 && stack[top] == '{') {
        
                top--;
            } else {
        
                return false;
            }
        }
    
        return top == -1;
    }
    
    int main() {
        
        const char *expression = "{[()]}";
        if (isValidParentheses(expression)) {
        
            printf("Valid parentheses expression.\n");
        } else {
        
            printf("Invalid parentheses expression.\n");
        }
        return 0;
    }

**题目14：** 编写一个程序，实现插入排序算法来对一个整数数组进行排序。

**答案14：**

#include <stdio.h>
    
    void insertionSort(int arr[], int size) {
        
        for (int i = 1; i < size; ++i) {
        
            int key = arr[i];
            int j = i - 1;
    
            while (j >= 0 && arr[j] > key) {
        
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
    }
    
    int main() {
        
        int arr[] = {
        12, 11, 13, 5, 6};
        int size = sizeof(arr) / sizeof(arr[0]);
    
        insertionSort(arr, size);
    
        printf("Sorted array: ");
        for (int i = 0; i < size; ++i) {
        
            printf("%d ", arr[i]);
        }
        printf("\n");
    
        return 0;
    }

**题目15：** 编写一个函数，接受一个整数参数 n，然后判断 n 是否为完全数（所有真因子之和等于自身）。

**答案15：**

#include <stdio.h>
    #include <stdbool.h>
    
    bool isPerfectNumber(int num) {
        
        if (num <= 1) {
        
            return false;
        }
    
        int sum = 1; // 1 is a factor for all numbers
    
        for (int i = 2; i * i <= num; ++i) {
        
            if (num % i == 0) {
        
                sum += i;
                if (i != num / i) {
        
                    sum += num / i;
                }
            }
        }
    
        return sum == num;
    }
    
    int main() {
        
        int num = 28;
        if (isPerfectNumber(num)) {
        
            printf("%d is a perfect number.\n", num);
        } else {
        
            printf("%d is not a perfect number.\n", num);
        }
        return 0;
    }

**题目16：** 编写一个程序，接受一个字符串参数，然后输出该字符串中出现频率最高的字符。

**答案16：**

#include <stdio.h>
    #include <string.h>
    
    void mostFrequentChar(const char *str) {
        
        int freq[256] = {
        0}; // Assuming ASCII characters
    
        for (int i = 0; str[i]; ++i) {
        
            freq[(unsigned char)str[i]]++;
        }
    
        char mostFreqChar = 0;
        int maxFrequency = 0;
    
        for (int i = 0; i < 256; ++i) {
        
            if (freq[i] > maxFrequency) {
        
                maxFrequency = freq[i];
                mostFreqChar = (char)i;
            }
        }
    
        printf("Most frequent character: %c\nFrequency: %d\n", mostFreqChar, maxFrequency);
    }
    
    int main() {
        
        const char *input = "programming";
        mostFrequentChar(input);
        return 0;
    }

**题目17：** 编写一个程序，实现选择排序算法来对一个整数数组进行排序。

**答案17：**

#include <stdio.h>
    
    void selectionSort(int arr[], int size) {
        
        for (int i = 0; i < size - 1; ++i) {
        
            int minIndex = i;
            for (int j = i + 1; j < size; ++j) {
        
                if (arr[j] < arr[minIndex]) {
        
                    minIndex = j;
                }
            }
            if (minIndex != i) {
        
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }
    
    int main() {
        
        int arr[] = {
        64, 25, 12, 22, 11};
        int size = sizeof(arr) / sizeof(arr[0]);
    
        selectionSort(arr, size);
    
        printf("Sorted array: ");
        for (int i = 0; i < size; ++i) {
        
            printf("%d ", arr[i]);
        }
        printf("\n");
    
        return 0;
    }

**题目18：** 编写一个函数，接受一个整数参数 n，然后生成一个帕斯卡三角形的前 n 行。

**答案18：**

#include <stdio.h>
    
    int binomialCoefficient(int n, int k) {
        
        if (k == 0 || k == n) {
        
            return 1;
        }
        return binomialCoefficient(n - 1, k - 1) + binomialCoefficient(n - 1, k);
    }
    
    void generatePascalTriangle(int numRows) {
        
        for (int i = 0; i < numRows; ++i) {
        
            for (int j = 0; j <= i; ++j) {
        
                printf("%d ", binomialCoefficient(i, j));
            }
            printf("\n");
        }
    }
    
    int main() {
        
        int numRows = 5;
        generatePascalTriangle(numRows);
        return 0;
    }

**题目19：** 编写一个函数，接受一个字符串参数，然后检查该字符串是否是回文串（忽略非字母和数字字符）。

**答案19：**

#include <stdio.h>
    #include <stdbool.h>
    #include <ctype.h>
    #include <
    
    string.h>
    
    bool isPalindromeString(const char *str) {
        
        int left = 0;
        int right = strlen(str) - 1;
    
        while (left < right) {
        
            while (left < right && !isalnum(str[left])) {
        
                left++;
            }
            while (left < right && !isalnum(str[right])) {
        
                right--;
            }
    
            if (tolower(str[left]) != tolower(str[right])) {
        
                return false;
            }
    
            left++;
            right--;
        }
    
        return true;
    }
    
    int main() {
        
        const char *input = "A man, a plan, a canal, Panama!";
        if (isPalindromeString(input)) {
        
            printf("The string is a palindrome.\n");
        } else {
        
            printf("The string is not a palindrome.\n");
        }
        return 0;
    }

**题目20：** 编写一个函数，接受一个整数参数 n，然后生成一个 n × n 的螺旋矩阵，从 1 到 n^2 依次填入。

**答案20：**