破解C语言编程难题：50个实战例题详解，助你快速提升编程技能

引言

C语言作为一种基础且强大的编程语言，广泛应用于系统开发、嵌入式系统、游戏开发等领域。掌握C语言编程，不仅需要扎实的理论基础，更需要大量的实战练习。本文将针对C语言编程中的常见难题，提供50个实战例题详解，帮助读者快速提升编程技能。

例题1：计算阶乘

#include <stdio.h>

long long factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

int main() {
    int num;
    printf("Enter a number: ");
    scanf("%d", &num);
    printf("Factorial of %d is %lld\n", num, factorial(num));
    return 0;
}

解析

本例题通过递归函数计算阶乘，展示了C语言中递归的使用方法。

例题2：冒泡排序

#include <stdio.h>

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

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);
    bubbleSort(arr, n);
    printf("Sorted array: \n");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

解析

冒泡排序是一种简单的排序算法，通过比较相邻元素并交换位置来对数组进行排序。

例题3：字符串反转

#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[] = "Hello, World!";
    printf("Original string: %s\n", str);
    reverseString(str);
    printf("Reversed string: %s\n", str);
    return 0;
}

解析

本例题通过交换字符串首尾字符的方法实现字符串反转。

例题4：计算最大公约数

#include <stdio.h>

int gcd(int a, int b) {
    if (b == 0)
        return a;
    return gcd(b, a % b);
}

int main() {
    int num1, num2;
    printf("Enter two numbers: ");
    scanf("%d %d", &num1, &num2);
    printf("GCD of %d and %d is %d\n", num1, num2, gcd(num1, num2));
    return 0;
}

解析

本例题使用递归方法计算两个整数的最大公约数。

例题5：斐波那契数列

#include <stdio.h>

void printFibonacci(int n) {
    int a = 0, b = 1, c;
    if (n < 1) return;
    for (int i = 0; i < n; i++) {
        if (i <= 1)
            c = i;
        else {
            c = a + b;
            a = b;
            b = c;
        }
        printf("%d ", c);
    }
    printf("\n");
}

int main() {
    int n;
    printf("Enter the number of terms: ");
    scanf("%d", &n);
    printf("Fibonacci Series: \n");
    printFibonacci(n);
    return 0;
}

解析

本例题通过循环计算斐波那契数列的前n项。

例题6：二分查找

#include <stdio.h>

int binarySearch(int arr[], int l, int r, int x) {
    if (r >= l) {
        int mid = l + (r - l) / 2;
        if (arr[mid] == x) return mid;
        if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);
        return binarySearch(arr, mid + 1, r, x);
    }
    return -1;
}

int main() {
    int arr[] = {2, 3, 4, 10, 40};
    int n = sizeof(arr) / sizeof(arr[0]);
    int x = 10;
    int result = binarySearch(arr, 0, n - 1, x);
    if (result == -1)
        printf("Element is not present in array");
    else
        printf("Element is present at index %d", result);
    return 0;
}

解析

二分查找是一种高效的查找算法，通过将数组分为两半来逐步缩小查找范围。

例题7：快速排序

#include <stdio.h>

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

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = (low - 1);
    for (int j = low; j <= high - 1; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

int main() {
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    quickSort(arr, 0, n - 1);
    printf("Sorted array: \n");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

解析

快速排序是一种高效的排序算法，通过递归将数组分为两部分，并对这两部分进行排序。

例题8：链表反转

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

struct Node {
    int data;
    struct Node* next;
};

void reverseList(struct Node** head_ref) {
    struct Node* prev = NULL;
    struct Node* current = *head_ref;
    struct Node* next = NULL;
    while (current != NULL) {
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }
    *head_ref = prev;
}

void printList(struct Node* node) {
    while (node != NULL) {
        printf("%d ", node->data);
        node = node->next;
    }
    printf("\n");
}

int main() {
    struct Node* head = (struct Node*)malloc(sizeof(struct Node));
    head->data = 1;
    head->next = (struct Node*)malloc(sizeof(struct Node));
    head->next->data = 2;
    head->next->next = (struct Node*)malloc(sizeof(struct Node));
    head->next->next->data = 3;
    head->next->next->next = NULL;
    printf("Original list: \n");
    printList(head);
    reverseList(&head);
    printf("Reversed list: \n");
    printList(head);
    return 0;
}

解析

本例题通过修改链表节点的指针实现链表反转。

例题9：递归函数求和

#include <stdio.h>

int sum(int n) {
    if (n <= 1) return n;
    return n + sum(n - 1);
}

int main() {
    int n;
    printf("Enter a number: ");
    scanf("%d", &n);
    printf("Sum of first %d natural numbers is %d\n", n, sum(n));
    return 0;
}

解析

本例题通过递归函数计算前n个自然数的和。

例题10：判断素数

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

bool isPrime(int n) {
    if (n <= 1) return false;
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) return false;
    }
    return true;
}

int main() {
    int n;
    printf("Enter a number: ");
    scanf("%d", &n);
    if (isPrime(n))
        printf("%d is a prime number\n", n);
    else
        printf("%d is not a prime number\n", n);
    return 0;
}

解析

本例题通过判断一个数是否只能被1和自身整除来判断其是否为素数。

例题11：字符串查找

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

int findSubstring(char str1[], char str2[]) {
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    for (int i = 0; i <= len1 - len2; i++) {
        int j;
        for (j = 0; j < len2; j++)
            if (str1[i + j] != str2[j])
                break;
        if (j == len2)
            return i;
    }
    return -1;
}

int main() {
    char str1[] = "Hello, World!";
    char str2[] = "World";
    int result = findSubstring(str1, str2);
    if (result == -1)
        printf("Substring not found");
    else
        printf("Substring found at index %d", result);
    return 0;
}

解析

本例题通过遍历主字符串并在每个位置查找子字符串的方法实现字符串查找。

例题12：反转整数

#include <stdio.h>

int reverse(int num) {
    int reversed = 0;
    while (num != 0) {
        reversed = reversed * 10 + num % 10;
        num /= 10;
    }
    return reversed;
}

int main() {
    int num;
    printf("Enter an integer: ");
    scanf("%d", &num);
    printf("Reversed integer: %d\n", reverse(num));
    return 0;
}

解析

本例题通过循环将整数的每一位反转，实现整数反转。

例题13：判断回文数

#include <stdio.h>

bool isPalindrome(int x) {
    if (x < 0) return false;
    int reversed = 0, original = x;
    while (x != 0) {
        reversed = reversed * 10 + x % 10;
        x /= 10;
    }
    return original == reversed;
}

int main() {
    int num;
    printf("Enter an integer: ");
    scanf("%d", &num);
    if (isPalindrome(num))
        printf("%d is a palindrome\n", num);
    else
        printf("%d is not a palindrome\n", num);
    return 0;
}

解析

本例题通过比较整数与其反转后的值来判断其是否为回文数。

例题14：计算最大子数组和

#include <stdio.h>

int maxSubArraySum(int arr[], int size) {
    int max_so_far = arr[0], max_ending_here = arr[0];
    for (int i = 1; i < size; i++) {
        max_ending_here = (arr[i] > max_ending_here + arr[i]) ? arr[i] : max_ending_here + arr[i];
        max_so_far = (max_so_far > max_ending_here) ? max_so_far : max_ending_here;
    }
    return max_so_far;
}

int main() {
    int arr[] = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
    int size = sizeof(arr) / sizeof(arr[0]);
    printf("Maximum subarray sum is %d\n", maxSubArraySum(arr, size));
    return 0;
}

解析

本例题使用Kadane算法计算数组中最大子数组和。

例题15：合并两个有序数组

#include <stdio.h>

void merge(int arr[], int n1, int n2) {
    int i = 0, j = 0, k = 0;
    while (i < n1 && j < n2) {
        if (arr[i] <= arr[j]) {
            arr[k] = arr[i];
            i++;
        } else {
            arr[k] = arr[j];
            j++;
        }
        k++;
    }
    while (i < n1) {
        arr[k] = arr[i];
        i++;
        k++;
    }
    while (j < n2) {
        arr[k] = arr[j];
        j++;
        k++;
    }
}

int main() {
    int arr1[] = {1, 3, 5, 7};
    int arr2[] = {2, 4, 6, 8};
    int n1 = sizeof(arr1) / sizeof(arr1[0]);
    int n2 = sizeof(arr2) / sizeof(arr2[0]);
    merge(arr1, n1, n2);
    printf("Merged array: \n");
    for (int i = 0; i < n1 + n2; i++)
        printf("%d ", arr1[i]);
    printf("\n");
    return 0;
}

解析

本例题通过比较两个有序数组中的元素，将它们合并成一个有序数组。

例题16：查找旋转排序数组中的元素

#include <stdio.h>

int search(int arr[], int l, int r, int x) {
    while (l <= r) {
        int m = l + (r - l) / 2;
        if (arr[m] == x) return m;
        if (arr[m] > arr[l]) {
            if (x >= arr[l] && x < arr[m])
                r = m - 1;
            else
                l = m + 1;
        } else {
            if (x > arr[m] && x <= arr[r])
                l = m + 1;
            else
                r = m - 1;
        }
    }
    return -1;
}

int main() {
    int arr[] = {4, 5, 6, 7, 0, 1, 2};
    int n = sizeof(arr) / sizeof(arr[0]);
    int x = 6;
    int result = search(arr, 0, n - 1, x);
    if (result == -1)
        printf("Element is not present in array");
    else
        printf("Element is present at index %d", result);
    return 0;
}

解析

本例题在旋转排序数组中查找元素，通过比较中间元素与首尾元素的关系来确定查找范围。

例题17：删除链表中的节点

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

struct Node {
    int data;
    struct Node* next;
};

void deleteNode(struct Node** head_ref, int key) {
    struct Node* temp = *head_ref, *prev = NULL;
    if (temp != NULL && temp->data == key) {
        *head_ref = temp->next;
        free(temp);
        return;
    }
    while (temp != NULL && temp->data != key) {
        prev = temp;
        temp = temp->next;
    }
    if (temp == NULL) return;
    prev->next = temp->next;
    free(temp);
}

void printList(struct Node* node) {
    while (node != NULL) {
        printf("%d ", node->data);
        node = node->next;
    }
    printf("\n");
}

int main() {
    struct Node* head = (struct Node*)malloc(sizeof(struct Node));
    head->data = 1;
    struct Node* second = (struct Node*)malloc(sizeof(struct Node));
    head->next = second;
    second->data = 2;
    second->next = NULL;
    printf("Original list: \n");
    printList(head);
    deleteNode(&head, 2);
    printf("List after deleting 2: \n");
    printList(head);
    return 0;
}

解析

本例题通过遍历链表找到要删除的节点，并将其从链表中移除。

例题18：计算字符串长度

#include <stdio.h>

int stringLength(char str[]) {
    int length = 0;
    while (str[length] != '\0')
        length++;
    return length;
}

int main() {
    char str[] = "Hello, World!";
    printf("Length of string: %d\n", stringLength(str));
    return 0;
}

解析

本例题通过遍历字符串直到遇到空字符’\0’来计算字符串长度。

例题19：字符串复制

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

void stringCopy(char dest[], char src[]) {
    int i = 0;
    while (src[i] != '\0') {
        dest[i] = src[i];
        i++;
    }
    dest[i] = '\0';
}

int main() {
    char src[] = "Hello, World!";
    char dest[100];
    stringCopy(dest, src);
    printf("Copied string: %s\n", dest);
    return 0;
}

解析

本例题通过遍历源字符串并将每个字符复制到目标字符串中来实现字符串复制。

例题20：字符串比较

”`c #include #include

int stringCompare(char str1[], char str2[]) {

int i = 0;
while (str1