掌握C语言，实战解析：50个实用编程案例详解

案例一：计算阶乘

主题句

理解阶乘的概念，并学会使用循环和递归方法计算阶乘。

#include <stdio.h>

// 递归计算阶乘
long long factorial_recursive(int n) {
    if (n == 0)
        return 1;
    return n * factorial_recursive(n - 1);
}

// 循环计算阶乘
long long factorial_iterative(int n) {
    long long result = 1;
    for (int i = 1; i <= n; i++) {
        result *= i;
    }
    return result;
}

int main() {
    int number = 5;
    printf("递归方法计算%d的阶乘: %lld\n", number, factorial_recursive(number));
    printf("循环方法计算%d的阶乘: %lld\n", number, factorial_iterative(number));
    return 0;
}

案例二：冒泡排序

主题句

掌握冒泡排序算法，并学会如何实现排序功能。

#include <stdio.h>

void bubble_sort(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[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, n);
    printf("排序后的数组: \n");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

案例三：字符串反转

主题句

学习如何反转一个字符串，并掌握指针的使用。

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

void reverse_string(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("原始字符串: %s\n", str);
    reverse_string(str);
    printf("反转后的字符串: %s\n", str);
    return 0;
}

案例四：二分查找

主题句

了解二分查找算法，并学会在有序数组中查找元素。

#include <stdio.h>

int binary_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] < x)
            l = m + 1;
        else
            r = m - 1;
    }
    return -1;
}

int main() {
    int arr[] = {2, 3, 4, 10, 40};
    int n = sizeof(arr) / sizeof(arr[0]);
    int x = 10;
    int result = binary_search(arr, 0, n - 1, x);
    if (result == -1)
        printf("元素不在数组中\n");
    else
        printf("元素在索引 %d\n", result);
    return 0;
}

案例五：递归查找最大值

主题句

通过递归方法查找数组中的最大值，加深对递归的理解。

#include <stdio.h>

int find_max(int arr[], int n) {
    if (n == 1)
        return arr[0];
    return (arr[n - 1] > find_max(arr, n - 1)) ? arr[n - 1] : find_max(arr, n - 1);
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("数组中的最大值: %d\n", find_max(arr, n));
    return 0;
}

案例六：链表反转

主题句

了解链表结构，并学会反转一个单链表。

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

// 创建一个新节点
struct Node {
    int data;
    struct Node* next;
};

// 反转链表
struct Node* reverse(struct Node* head) {
    struct Node* prev = NULL;
    struct Node* current = head;
    struct Node* next = NULL;
    while (current != NULL) {
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }
    head = prev;
    return head;
}

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;

    printf("反转前的链表: ");
    struct Node* temp = head;
    while (temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");

    head = reverse(head);
    printf("反转后的链表: ");
    temp = head;
    while (temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");

    return 0;
}

案例七：快速排序

主题句

理解快速排序算法，并学会如何实现快速排序。

#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("排序后的数组: \n");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

案例八：矩阵乘法

主题句

学习如何计算两个矩阵的乘积，并了解矩阵的基本操作。

#include <stdio.h>

void multiply(int a[][3], int b[][3], int result[][3]) {
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++) {
            result[i][j] = 0;
            for (int k = 0; k < 3; k++)
                result[i][j] += a[i][k] * b[k][j];
        }
}

void printMatrix(int mat[][3]) {
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            printf("%d ", mat[i][j]);
    printf("\n");
}

int main() {
    int a[3][3] = {{1, 1, 1}, {2, 2, 2}, {3, 3, 3}};
    int b[3][3] = {{1, 1, 1}, {2, 2, 2}, {3, 3, 3}};
    int result[3][3];

    multiply(a, b, result);
    printf("矩阵乘积: \n");
    printMatrix(result);
    return 0;
}

案例九：斐波那契数列

主题句

理解斐波那契数列的生成原理，并学会使用循环和递归方法计算斐波那契数列。

#include <stdio.h>

// 递归方法
int fibonacci_recursive(int n) {
    if (n <= 1)
        return n;
    return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2);
}

// 循环方法
int fibonacci_iterative(int n) {
    if (n <= 1)
        return n;
    int a = 0, b = 1, c;
    for (int i = 2; i <= n; i++) {
        c = a + b;
        a = b;
        b = c;
    }
    return b;
}

int main() {
    int n = 10;
    printf("递归方法计算斐波那契数列的第%d项: %d\n", n, fibonacci_recursive(n));
    printf("循环方法计算斐波那契数列的第%d项: %d\n", n, fibonacci_iterative(n));
    return 0;
}

案例十：哈希表

主题句

了解哈希表的基本原理，并学会如何实现一个简单的哈希表。

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

#define TABLE_SIZE 10

typedef struct Node {
    int key;
    int value;
    struct Node* next;
} Node;

Node* hash_table[TABLE_SIZE];

// 哈希函数
unsigned int hash(int key) {
    return key % TABLE_SIZE;
}

// 插入函数
void insert(int key, int value) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->key = key;
    new_node->value = value;
    new_node->next = NULL;

    unsigned int index = hash(key);
    new_node->next = hash_table[index];
    hash_table[index] = new_node;
}

// 查找函数
int find(int key) {
    unsigned int index = hash(key);
    Node* temp = hash_table[index];
    while (temp != NULL) {
        if (temp->key == key)
            return temp->value;
        temp = temp->next;
    }
    return -1;
}

int main() {
    insert(1, 10);
    insert(2, 20);
    insert(3, 30);

    printf("查找键值1的值: %d\n", find(1));
    printf("查找键值2的值: %d\n", find(2));
    printf("查找键值3的值: %d\n", find(3));
    printf("查找键值4的值: %d\n", find(4)); // 不存在

    return 0;
}

案例十一：动态内存分配

主题句

了解动态内存分配的概念，并学会如何使用malloc和free函数。

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

int main() {
    int* ptr = (int*)malloc(10 * sizeof(int));
    if (ptr == NULL) {
        printf("内存分配失败\n");
        exit(0);
    }
    for (int i = 0; i < 10; i++)
        ptr[i] = i;

    printf("动态分配的数组: ");
    for (int i = 0; i < 10; i++)
        printf("%d ", ptr[i]);
    printf("\n");

    free(ptr);
    return 0;
}

案例十二：文件操作

主题句

学习如何进行文件读写操作，并了解文件的基本概念。

#include <stdio.h>

int main() {
    FILE* file = fopen("example.txt", "w");
    if (file == NULL) {
        printf("文件打开失败\n");
        exit(0);
    }
    fprintf(file, "Hello, World!\n");
    fclose(file);

    file = fopen("example.txt", "r");
    if (file == NULL) {
        printf("文件打开失败\n");
        exit(0);
    }
    char buffer[100];
    while (fgets(buffer, sizeof(buffer), file)) {
        printf("%s", buffer);
    }
    fclose(file);

    return 0;
}

案例十三：结构体

主题句

了解结构体的概念，并学会如何定义和使用结构体。

#include <stdio.h>

typedef struct {
    int x;
    int y;
} Point;

void print_point(Point p) {
    printf("Point: (%d, %d)\n", p.x, p.y);
}

int main() {
    Point p1 = {1, 2};
    Point p2 = {3, 4};
    print_point(p1);
    print_point(p2);
    return 0;
}

案例十四：指针和数组

主题句

掌握指针和数组的关系，并学会如何使用指针操作数组。

#include <stdio.h>

void print_array(int* arr, int size) {
    for (int i = 0; i < size; i++)
        printf("%d ", *(arr + i));
    printf("\n");
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    print_array(arr, size);
    return 0;
}

案例十五：函数指针

主题句

了解函数指针的概念，并学会如何使用函数指针。

#include <stdio.h>

int add(int a, int b) {
    return a + b;
}

int main() {
    int (*func_ptr)(int, int) = add;
    printf("函数指针调用: %d\n", func_ptr(3, 4));
    return 0;
}

案例十六：结构体指针

主题句

了解结构体指针的概念，并学会如何使用结构体指针。

#include <stdio.h>

typedef struct {
    int x;
    int y;
} Point;

void print_point(const Point* p) {
    printf("Point: (%d, %d)\n", p->x, p->y);
}

int main() {
    Point p = {1, 2};
    print_point(&p);
    return 0;
}

案例十七：位操作

主题句

了解位操作的概念，并学会如何使用位操作。

#include <stdio.h>

int main() {
    int a = 5; // 0101
    int b = 3; // 0011

    printf("a & b: %d\n", a & b); // 0001
    printf("a | b: %d\n", a | b); // 0111
    printf("a ^ b: %d\n", a ^ b); // 0110
    printf("a << 1: %d\n", a << 1); // 1010
    printf("a >> 1: %d\n", a >> 1); // 0101

    return 0;
}

案例十八：文件系统操作

主题句

了解文件系统的基本概念，并学会如何进行文件系统操作。

#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>

int main() {
    // 创建文件
    FILE* file = fopen("example.txt", "w");
    if (file == NULL) {
        printf("文件创建失败\n");
        exit(1);
    }
    fprintf(file, "Hello, World!\n");
    fclose(file);

    // 检查文件是否存在
    struct stat st;
    if (stat("example.txt", &st) == -1) {
        printf("文件不存在\n");
    } else {
        printf("文件存在\n");
    }

    // 删除文件
    remove("example.txt");

    return 0;
}

案例十九：进程和线程

主题句

了解进程和线程的概念，并学会如何创建和使用进程和线程。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

void child_process() {
    printf("这是子进程\n");
}

void main_process() {
    pid_t pid = fork();
    if (pid == 0) {
        // 子进程
        child_process();
    } else {
        // 父进程
        printf("这是父进程\n");
        wait(NULL);
    }
}

int main() {
    main_process();
    return 0;
}

案例二十：网络编程

主题句

了解网络编程的基本概念，并学会如何使用socket进行网络通信。

”`c #include #include #include #include #include #include

int main() {

int server_fd, new_socket;
struct sockaddr_in address;
int opt = 1;
int addrlen = sizeof(address);

// 创建socket文件描述符
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
    perror("socket failed");
    exit(EXIT_FAILURE);
}

// 强制绑定到端口8080
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
    perror("setsockopt");
    exit(EXIT_FAILURE);
}
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port