破解C语言编程难题，30个实用实例教你高效学编程

在编程的世界里，C语言以其高效、灵活和强大的功能，一直被广大开发者所青睐。学习C语言，不仅可以让你掌握一门实用的编程语言，更能锻炼你的逻辑思维和解决问题的能力。本文将为你带来30个实用实例，帮助你破解C语言编程难题，高效学习编程。

实例1：计算两个整数的和

#include <stdio.h>

int main() {
    int a, b, sum;
    printf("请输入两个整数：");
    scanf("%d %d", &a, &b);
    sum = a + b;
    printf("两个整数的和为：%d\n", sum);
    return 0;
}

实例2：判断一个数是否为素数

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

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

int main() {
    int num;
    printf("请输入一个整数：");
    scanf("%d", &num);
    if (is_prime(num)) {
        printf("%d 是素数\n", num);
    } else {
        printf("%d 不是素数\n", num);
    }
    return 0;
}

实例3：实现冒泡排序

#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[] = {5, 2, 8, 12, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, n);
    printf("排序后的数组：");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

实例4：实现选择排序

#include <stdio.h>

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

int main() {
    int arr[] = {5, 2, 8, 12, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    selection_sort(arr, n);
    printf("排序后的数组：");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

实例5：实现插入排序

#include <stdio.h>

void insertion_sort(int arr[], int n) {
    int i, key, j;
    for (i = 1; i < n; i++) {
        key = arr[i];
        j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}

int main() {
    int arr[] = {5, 2, 8, 12, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    insertion_sort(arr, n);
    printf("排序后的数组：");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

实例6：实现快速排序

#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 quick_sort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quick_sort(arr, low, pi - 1);
        quick_sort(arr, pi + 1, high);
    }
}

int main() {
    int arr[] = {5, 2, 8, 12, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    quick_sort(arr, 0, n - 1);
    printf("排序后的数组：");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

实例7：实现归并排序

#include <stdio.h>

void merge(int arr[], int l, int m, int r) {
    int i, j, k;
    int n1 = m - l + 1;
    int n2 = r - m;
    int L[n1], R[n2];
    for (i = 0; i < n1; i++)
        L[i] = arr[l + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[m + 1 + j];
    i = 0;
    j = 0;
    k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

void merge_sort(int arr[], int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;
        merge_sort(arr, l, m);
        merge_sort(arr, m + 1, r);
        merge(arr, l, m, r);
    }
}

int main() {
    int arr[] = {5, 2, 8, 12, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    merge_sort(arr, 0, n - 1);
    printf("排序后的数组：");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

实例8：实现二分查找

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

实例9：实现斐波那契数列

#include <stdio.h>

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

int main() {
    int n = 10;
    fibonacci(n);
    return 0;
}

实例10：实现汉诺塔问题

#include <stdio.h>

void hanoi(int n, char from_rod, char to_rod, char aux_rod) {
    if (n == 1) {
        printf("移动盘子 %d 从 %c 到 %c\n", n, from_rod, to_rod);
        return;
    }
    hanoi(n - 1, from_rod, aux_rod, to_rod);
    printf("移动盘子 %d 从 %c 到 %c\n", n, from_rod, to_rod);
    hanoi(n - 1, aux_rod, to_rod, from_rod);
}

int main() {
    int n = 3;
    hanoi(n, 'A', 'C', 'B');
    return 0;
}

实例11：实现素数筛法

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

void sieve_of_eratosthenes(int n) {
    bool prime[n + 1];
    for (int i = 0; i <= n; i++)
        prime[i] = true;
    for (int p = 2; p * p <= n; p++) {
        if (prime[p] == true) {
            for (int i = p * p; i <= n; i += p)
                prime[i] = false;
        }
    }
    for (int p = 2; p <= n; p++) {
        if (prime[p])
            printf("%d ", p);
    }
}

int main() {
    int n = 30;
    sieve_of_eratosthenes(n);
    return 0;
}

实例12：实现链表反转

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

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

void reverse(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));
    struct Node* second = (struct Node*)malloc(sizeof(struct Node));
    struct Node* third = (struct Node*)malloc(sizeof(struct Node));
    head->data = 1;
    head->next = second;
    second->data = 2;
    second->next = third;
    third->data = 3;
    third->next = NULL;
    printf("反转前的链表：");
    printList(head);
    reverse(&head);
    printf("反转后的链表：");
    printList(head);
    return 0;
}

实例13：实现栈的遍历

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

#define MAX 100

struct Stack {
    int items[MAX];
    int top;
};

void initialize(struct Stack* s) {
    s->top = -1;
}

int isEmpty(struct Stack* s) {
    return s->top == -1;
}

void push(struct Stack* s, int item) {
    if (s->top == MAX - 1) {
        printf("栈已满\n");
        return;
    }
    s->items[++s->top] = item;
}

int pop(struct Stack* s) {
    if (isEmpty(s)) {
        printf("栈为空\n");
        return -1;
    }
    return s->items[s->top--];
}

void traverse(struct Stack* s) {
    printf("栈的元素：");
    for (int i = s->top; i >= 0; i--) {
        printf("%d ", s->items[i]);
    }
    printf("\n");
}

int main() {
    struct Stack s;
    initialize(&s);
    push(&s, 1);
    push(&s, 2);
    push(&s, 3);
    traverse(&s);
    pop(&s);
    traverse(&s);
    return 0;
}

实例14：实现队列的遍历

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

#define MAX 100

struct Queue {
    int items[MAX];
    int front, rear;
};

void initialize(struct Queue* q) {
    q->front = q->rear = -1;
}

int isEmpty(struct Queue* q) {
    return q->front == -1;
}

void enqueue(struct Queue* q, int item) {
    if ((q->rear + 1) % MAX == q->front) {
        printf("队列已满\n");
        return;
    }
    if (isEmpty(q)) {
        q->front = q->rear = 0;
    } else {
        q->rear = (q->rear + 1) % MAX;
    }
    q->items[q->rear] = item;
}

int dequeue(struct Queue* q) {
    if (isEmpty(q)) {
        printf("队列已空\n");
        return -1;
    }
    int item = q->items[q->front];
    if (q->front == q->rear) {
        q->front = q->rear = -1;
    } else {
        q->front = (q->front + 1) % MAX;
    }
    return item;
}

void traverse(struct Queue* q) {
    printf("队列的元素：");
    int i = q->front;
    while (i != q->rear) {
        printf("%d ", q->items[i]);
        i = (i + 1) % MAX;
    }
    printf("\n");
}

int main() {
    struct Queue q;
    initialize(&q);
    enqueue(&q, 1);
    enqueue(&q, 2);
    enqueue(&q, 3);
    traverse(&q);
    dequeue(&q);
    traverse(&q);
    return 0;
}

实例15：实现栈与队列的转换

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

#define MAX 100

struct Stack {
    int items[MAX];
    int top;
};

void initialize(struct Stack* s) {
    s->top = -1;
}

int isEmpty(struct Stack* s) {
    return s->top == -1;
}

void push(struct Stack* s, int item) {
    if (s->top == MAX - 1) {
        printf("栈已满\n");
        return;
    }
    s->items[++s->top] = item;
}

int pop(struct Stack* s) {
    if (isEmpty(s)) {
        printf("栈为空\n");
        return -1;
    }
    return s->items[s->top--];
}

struct Queue {
    int items[MAX];
    int front, rear;
};

void initialize(struct Queue* q) {
    q->front = q->rear = -1;
}

int isEmpty(struct Queue* q) {
    return q->front == -1;
}

void enqueue(struct Queue* q, int item) {
    if ((q->rear + 1) % MAX == q->front) {
        printf("队列已满\n");
        return;
    }
    if (isEmpty(q)) {
        q->front = q->rear = 0;
    } else {
        q->rear = (q->rear + 1) % MAX;
    }
    q->items[q->rear] = item;
}

int dequeue(struct Queue* q) {
    if (isEmpty(q)) {
        printf("队列已空\n");
        return -1;
    }
    int item = q->items[q->front];
    if (q->front == q->rear) {
        q->front = q->rear = -1;
    } else {
        q->front = (q->front + 1) % MAX;
    }
    return item;
}

void stack_to_queue(struct Stack* s, struct Queue* q) {
    while (!isEmpty(s)) {
        enqueue(q, pop(s));
    }
}

void queue_to_stack(struct Stack* s, struct Queue* q) {
    while (!isEmpty(q)) {
        push(s, dequeue(q));
    }
}

int main() {
    struct Stack s;
    struct Queue q;
    initialize(&s);
    initialize(&q);
    for (int i = 0; i < 5; i++) {
        push(&s, i);
    }
    stack_to_queue(&s, &q);
    printf("栈转换为队列后的元素：");
    while (!isEmpty(q)) {
        printf("%d ", dequeue(&q));
    }
    printf("\n");
    queue_to_stack(&s, &q);
    printf("队列转换为栈后的元素：");
    while (!isEmpty(s)) {
        printf("%d ", pop(&s));
    }
    printf("\n");
    return 0;
}

实例16：实现链表遍历

”`c #include #include

struct Node {

int data;
struct Node* next;

};

void printList(struct Node* node) {

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

}

struct Node* createNode(int data) {

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->next = NULL;
return newNode;

}

void appendNode(struct Node** head_ref, int data) {

struct Node* newNode = createNode(data);

正文

破解C语言编程难题，30个实用实例教你高效学编程

实例1：计算两个整数的和

实例2：判断一个数是否为素数

实例3：实现冒泡排序

实例4：实现选择排序

实例5：实现插入排序

实例6：实现快速排序

实例7：实现归并排序

实例8：实现二分查找

实例9：实现斐波那契数列

实例10：实现汉诺塔问题

实例11：实现素数筛法

实例12：实现链表反转

实例13：实现栈的遍历

实例14：实现队列的遍历

实例15：实现栈与队列的转换

实例16：实现链表遍历

相关阅读

掌握Java图形界面，轻松打造个性化应用，入门攻略来了！

从零开始：Go语言实战教程，轻松掌握高效编程技巧

轻松上手Android编程：实战案例深度解析，掌握实用技巧

学会Java图形界面：轻松打造互动软件，从零基础到实践入门指南

手机APP开发实战解析：轻松学会Android编程技巧与案例深度解读

掌握C语言编程，实战案例解析：从入门到精通，轻松解决实际问题

揭秘Lua与C语言融合：轻松实现高效性能的跨语言编程实践

揭秘Lua与C语言完美融合：跨语言编程实战技巧解析

Lua编程入门：轻松掌握多线程技巧，实现高效并发处理

从零开始：轻松掌握Linux编程技巧与实战案例