掌握C语言，从这50个经典编程实例开始

引言

C语言作为一种历史悠久且应用广泛的编程语言，其强大的功能和灵活性使其成为学习编程的入门首选。掌握C语言，不仅能帮助你理解计算机科学的基本原理，还能为后续学习其他编程语言打下坚实的基础。本文将为你提供50个经典编程实例，涵盖C语言的基础语法、数据结构、算法等多个方面，帮助你一步步迈向C语言的精通之路。

1. 数据类型与变量

实例1：变量声明与赋值

#include <stdio.h>

int main() {
    int a = 10;
    float b = 3.14;
    char c = 'A';
    printf("整数：%d\n", a);
    printf("浮点数：%f\n", b);
    printf("字符：%c\n", c);
    return 0;
}

实例2：数据类型转换

#include <stdio.h>

int main() {
    int a = 10;
    float b = (float)a;
    printf("转换后的浮点数：%f\n", b);
    return 0;
}

2. 控制语句

实例3：if语句

#include <stdio.h>

int main() {
    int a = 5;
    if (a > 0) {
        printf("a大于0\n");
    }
    return 0;
}

实例4：for循环

#include <stdio.h>

int main() {
    for (int i = 1; i <= 5; i++) {
        printf("循环中的变量i：%d\n", i);
    }
    return 0;
}

3. 函数

实例5：编写简单的函数

#include <stdio.h>

int add(int x, int y) {
    return x + y;
}

int main() {
    int a = 3;
    int b = 4;
    int sum = add(a, b);
    printf("两个数的和：%d\n", sum);
    return 0;
}

4. 数组

实例6：数组初始化与遍历

#include <stdio.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    for (int i = 0; i < 5; i++) {
        printf("数组元素：%d\n", arr[i]);
    }
    return 0;
}

5. 字符串

实例7：字符串输入与输出

#include <stdio.h>

int main() {
    char str[100];
    printf("请输入字符串：");
    scanf("%s", str);
    printf("输入的字符串：%s\n", str);
    return 0;
}

6. 指针

实例8：指针与数组

#include <stdio.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int *ptr = arr;
    for (int i = 0; i < 5; i++) {
        printf("指针访问数组元素：%d\n", *(ptr + i));
    }
    return 0;
}

7. 函数指针

实例9：函数指针的应用

#include <stdio.h>

int add(int x, int y) {
    return x + y;
}

int sub(int x, int y) {
    return x - y;
}

int main() {
    int (*ptr)(int, int);
    ptr = add;
    printf("加法结果：%d\n", (*ptr)(3, 4));
    ptr = sub;
    printf("减法结果：%d\n", (*ptr)(3, 4));
    return 0;
}

8. 结构体

实例10：结构体定义与使用

#include <stdio.h>

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

int main() {
    Point p1, p2;
    p1.x = 1;
    p1.y = 2;
    p2.x = 3;
    p2.y = 4;
    printf("p1坐标：%d, %d\n", p1.x, p1.y);
    printf("p2坐标：%d, %d\n", p2.x, p2.y);
    return 0;
}

9. 位操作

实例11：位运算符的应用

#include <stdio.h>

int main() {
    int a = 5; // 0101
    int b = 3; // 0011
    printf("按位与：%d\n", (a & b)); // 0001
    printf("按位或：%d\n", (a | b)); // 0111
    printf("按位异或：%d\n", (a ^ b)); // 0110
    printf("按位取反：%d\n", (~a)); // 1010
    return 0;
}

10. 预处理器

实例12：宏定义的应用

#include <stdio.h>

#define MAX 5

int main() {
    int arr[MAX] = {1, 2, 3, 4, 5};
    for (int i = 0; i < MAX; i++) {
        printf("数组元素：%d\n", arr[i]);
    }
    return 0;
}

11. 文件操作

实例13：文件读取与写入

#include <stdio.h>

int main() {
    FILE *fp = fopen("example.txt", "r");
    if (fp == NULL) {
        printf("打开文件失败\n");
        return 0;
    }
    char ch;
    while ((ch = fgetc(fp)) != EOF) {
        printf("%c", ch);
    }
    fclose(fp);
    return 0;
}

12. 链表

实例14：单链表创建与遍历

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

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

Node *createList(int *arr, int size) {
    Node *head = NULL, *tail = NULL;
    for (int i = 0; i < size; i++) {
        Node *newNode = (Node *)malloc(sizeof(Node));
        newNode->data = arr[i];
        newNode->next = NULL;
        if (head == NULL) {
            head = newNode;
            tail = newNode;
        } else {
            tail->next = newNode;
            tail = newNode;
        }
    }
    return head;
}

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

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    Node *list = createList(arr, size);
    printList(list);
    return 0;
}

13. 栈与队列

实例15：栈的创建与操作

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

#define MAX_SIZE 5

typedef struct {
    int data[MAX_SIZE];
    int top;
} Stack;

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

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

int isFull(Stack *s) {
    return s->top == MAX_SIZE - 1;
}

void push(Stack *s, int data) {
    if (!isFull(s)) {
        s->data[++s->top] = data;
    } else {
        printf("栈已满\n");
    }
}

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

int main() {
    Stack s;
    initStack(&s);
    push(&s, 1);
    push(&s, 2);
    push(&s, 3);
    printf("出栈元素：%d\n", pop(&s));
    printf("出栈元素：%d\n", pop(&s));
    return 0;
}

14. 树与图

实例16：二叉树创建与遍历

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

typedef struct Node {
    int data;
    struct Node *left;
    struct Node *right;
} Node;

Node *createNode(int data) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

void preOrder(Node *root) {
    if (root != NULL) {
        printf("%d ", root->data);
        preOrder(root->left);
        preOrder(root->right);
    }
}

void inOrder(Node *root) {
    if (root != NULL) {
        inOrder(root->left);
        printf("%d ", root->data);
        inOrder(root->right);
    }
}

void postOrder(Node *root) {
    if (root != NULL) {
        postOrder(root->left);
        postOrder(root->right);
        printf("%d ", root->data);
    }
}

int main() {
    Node *root = createNode(1);
    root->left = createNode(2);
    root->right = createNode(3);
    root->left->left = createNode(4);
    root->left->right = createNode(5);

    printf("前序遍历：");
    preOrder(root);
    printf("\n");

    printf("中序遍历：");
    inOrder(root);
    printf("\n");

    printf("后序遍历：");
    postOrder(root);
    printf("\n");

    return 0;
}

15. 动态内存分配

实例17：malloc、calloc和realloc函数的应用

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

int main() {
    int *arr = (int *)malloc(5 * sizeof(int));
    if (arr == NULL) {
        printf("内存分配失败\n");
        return 0;
    }
    for (int i = 0; i < 5; i++) {
        arr[i] = i;
    }
    printf("动态数组：");
    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    int *arr2 = (int *)calloc(5, sizeof(int));
    if (arr2 == NULL) {
        printf("内存分配失败\n");
        return 0;
    }
    for (int i = 0; i < 5; i++) {
        arr2[i] = i;
    }
    printf("动态数组：");
    for (int i = 0; i < 5; i++) {
        printf("%d ", arr2[i]);
    }
    printf("\n");

    int *arr3 = (int *)realloc(arr, 10 * sizeof(int));
    if (arr3 == NULL) {
        printf("内存分配失败\n");
        return 0;
    }
    for (int i = 5; i < 10; i++) {
        arr3[i] = i;
    }
    printf("动态数组：");
    for (int i = 0; i < 10; i++) {
        printf("%d ", arr3[i]);
    }
    printf("\n");

    free(arr);
    free(arr2);
    free(arr3);

    return 0;
}

16. 查找算法

实例18：二分查找

#include <stdio.h>

int binarySearch(int *arr, int left, int right, int target) {
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int target = 7;
    int index = binarySearch(arr, 0, 9, target);
    if (index != -1) {
        printf("找到目标值：%d，索引：%d\n", target, index);
    } else {
        printf("未找到目标值：%d\n", target);
    }
    return 0;
}

17. 排序算法

实例19：冒泡排序

#include <stdio.h>

void bubbleSort(int *arr, int size) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - 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, 3, 1};
    int size = sizeof(arr) / sizeof(arr[0]);
    bubbleSort(arr, size);
    printf("排序后的数组：");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

18. 链表查找与删除

实例20：链表查找

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

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

Node *createNode(int data) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

Node *findNode(Node *head, int data) {
    Node *current = head;
    while (current != NULL) {
        if (current->data == data) {
            return current;
        }
        current = current->next;
    }
    return NULL;
}

int main() {
    Node *head = createNode(1);
    head->next = createNode(2);
    head->next->next = createNode(3);
    head->next->next->next = createNode(4);
    head->next->next->next->next = createNode(5);

    int data = 3;
    Node *foundNode = findNode(head, data);
    if (foundNode != NULL) {
        printf("找到节点：%d\n", foundNode->data);
    } else {
        printf("未找到节点：%d\n", data);
    }

    return 0;
}

19. 链表删除

实例21：链表删除节点

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

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

Node *createNode(int data) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

void insertNode(Node *head, int data) {
    Node *newNode = createNode(data);
    newNode->next = head;
    head = newNode;
}

void deleteNode(Node *head, int data) {
    Node *current = head;
    Node *prev = NULL;
    while (current != NULL) {
        if (current->data == data) {
            if (prev == NULL) {
                head = current->next;
            } else {
                prev->next = current->next;
            }
            free(current);
            return;
        }
        prev = current;
        current = current->next;
    }
}

int main() {
    Node *head = createNode(1);
    insertNode(head, 2);
    insertNode(head, 3);
    insertNode(head, 4);
    insertNode(head, 5);

    int data = 3;
    deleteNode(head, data);

    printf("删除节点后的链表：");
    Node *current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");

    return 0;
}

20. 栈与队列的应用

实例22：栈实现队列

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

#define MAX_SIZE 5

typedef struct {
    int data[MAX_SIZE];
    int top;
} Stack;

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

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

void push(Stack *s, int data) {
    if (!isFull(s)) {
        s->data[++s->top] = data;
    } else {
        printf("栈已满\n");
    }
}

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

void queueUsingStacks(Stack *s1, Stack *s2) {
    while (!isEmpty(s1)) {
        push(s2, pop(s1));
    }
}

int main() {
    Stack s1, s2;
    initStack(&s1);
    initStack(&s2);

    push(&s1, 1);
    push(&s1, 2);
    push(&s1, 3);

    queueUsingStacks(&s1, &s2);

    printf("队列元素：");
    while (!isEmpty(s2)) {
        printf("%d ", pop(&s2));
    }
    printf("\n");

    return 0;
}

21. 字符串处理

实例23：字符串反转

”`c #include #include

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";
printf("原始字符串：%s\n", str);
reverse

正文

掌握C语言，从这50个经典编程实例开始

引言

1. 数据类型与变量

2. 控制语句

3. 函数

4. 数组

5. 字符串

6. 指针

7. 函数指针

8. 结构体

9. 位操作

10. 预处理器

11. 文件操作

12. 链表

13. 栈与队列

14. 树与图

15. 动态内存分配

16. 查找算法

17. 排序算法

18. 链表查找与删除

19. 链表删除

20. 栈与队列的应用

21. 字符串处理

相关阅读

学会Java，轻松打造酷炫界面：图形编程入门指南全解析

从零到实战：Swift编程入门与进阶经验全解析

掌握Android编程，实例解析入门必备技巧

从小白到高手：轻松掌握专业编程基础入门指南

孩子想学编程？揭秘专业培训班如何助力未来IT精英梦

新手必看！HTTP协议网络编程实战教程与案例详解

火山编程：揭秘新手如何轻松入门，一步步掌握热门编程语言技巧

火山编程：轻松学习编程，网址揭秘与实战技巧一网打尽

火山编程教你轻松掌握C语言调用技巧

火山编程轻松搞定DLL调用，入门教程助你一臂之力