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

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

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

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

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

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

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

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

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

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

如何使用这些练习题？

1. 逐个挑战：从基础到高级，逐步挑战这些练习题，不断提升自己的编程能力。

2. 实践是关键：不要只停留在理论，务必亲自动手操作，亲自编写代码。只有通过实际操作，才能真正理解和掌握编程。

3. 查阅文档：在解决问题时，如果遇到不熟悉的函数或概念，不要犹豫查阅官方文档或编程书籍。

4. 理解解答：在完成练习后，仔细阅读我们提供的答案，比较自己的解答与标准答案的差异，从中学习和改进。

结语

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

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

答案1：

#include 

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 

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 

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 
#include 
#include 

#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 
#include 

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 
#include 

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 
#include 
#include 

#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 
#include 

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 
#include 
#include 

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 

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 
#include 

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 

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 
#include 
#include 

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 

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 
#include 

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 
#include 

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 

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 

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 
#include 
#include 
#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：

#include 

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;
}