C语言编程入门：50个实用实例带你轻松掌握编程技巧

C语言，作为一种历史悠久的编程语言，以其高效和灵活的特性在编程领域占据着举足轻重的地位。对于编程初学者来说，C语言是了解计算机工作原理和编程技巧的绝佳选择。本篇文章将带领大家通过50个实用实例，轻松掌握C语言编程技巧。

实例1：Hello World程序

#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

这个程序是每个编程新手都应该掌握的基础。它展示了如何输出文字到控制台。

实例2：变量和数据类型

#include <stdio.h>

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

本实例介绍了C语言中的基本数据类型：整数、浮点数和字符。

实例3：运算符

#include <stdio.h>

int main() {
    int a = 5, b = 3;
    printf("加：%d\n", a + b);
    printf("减：%d\n", a - b);
    printf("乘：%d\n", a * b);
    printf("除：%d\n", a / b);
    return 0;
}

在这里，我们学习了加、减、乘、除等运算符。

实例4：条件语句

#include <stdio.h>

int main() {
    int age = 20;
    if (age >= 18) {
        printf("你成年了！\n");
    } else {
        printf("你还未成年。\n");
    }
    return 0;
}

本实例展示了如何使用条件语句来决定执行哪段代码。

实例5：循环结构

#include <stdio.h>

int main() {
    int i;
    for (i = 1; i <= 10; i++) {
        printf("%d ", i);
    }
    printf("\n");
    return 0;
}

循环结构可以重复执行代码块，本实例使用了for循环打印1到10的数字。

实例6：数组操作

#include <stdio.h>

int main() {
    int numbers[5] = {1, 2, 3, 4, 5};
    printf("第一个元素：%d\n", numbers[0]);
    printf("最后一个元素：%d\n", numbers[4]);
    return 0;
}

数组是C语言中的基本数据结构之一，本实例演示了如何访问数组中的元素。

实例7：指针简介

#include <stdio.h>

int main() {
    int a = 10, *ptr;
    ptr = &a;
    printf("变量的地址：%p\n", (void*)&a);
    printf("指针的地址：%p\n", (void*)ptr);
    printf("通过指针访问变量：%d\n", *ptr);
    return 0;
}

指针是C语言中的一个强大特性，本实例简单介绍了指针的概念。

实例8：函数定义和调用

#include <stdio.h>

void myFunction() {
    printf("Hello, Function!\n");
}

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

函数是代码的可重用部分，本实例展示了如何定义和调用函数。

实例9：结构体

#include <stdio.h>

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

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

结构体用于组合多个数据项，本实例创建了一个包含两个整数的点结构体。

实例10：文件操作

#include <stdio.h>

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

文件操作是C语言的一个重要方面，本实例展示了如何读取一个文本文件。

实例11：字符串处理

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

int main() {
    char str1[] = "Hello, ";
    char str2[] = "World!";
    char result[50];
    strcpy(result, str1);
    strcat(result, str2);
    printf("结果：%s\n", result);
    return 0;
}

字符串处理是编程中的常见需求，本实例演示了字符串复制和连接操作。

实例12：内存管理

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

int main() {
    int *ptr = (int *)malloc(10 * sizeof(int));
    if (ptr == NULL) {
        printf("内存分配失败\n");
        return 1;
    }
    for (int i = 0; i < 10; i++) {
        *(ptr + i) = i;
    }
    for (int i = 0; i < 10; i++) {
        printf("%d ", *(ptr + i));
    }
    free(ptr);
    return 0;
}

本实例介绍了如何动态分配和释放内存。

实例13：链表操作

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

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

int main() {
    Node *head = (Node *)malloc(sizeof(Node));
    Node *second = (Node *)malloc(sizeof(Node));
    Node *third = (Node *)malloc(sizeof(Node));

    head->data = 1;
    head->next = second;

    second->data = 2;
    second->next = third;

    third->data = 3;
    third->next = NULL;

    printf("链表元素：");
    Node *current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");

    free(head);
    free(second);
    free(third);
    return 0;
}

链表是C语言中的高级数据结构，本实例展示了如何创建和操作链表。

实例14：递归函数

#include <stdio.h>

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

int main() {
    int num = 5;
    printf("5的阶乘：%d\n", factorial(num));
    return 0;
}

递归函数是C语言中的一个高级技巧，本实例计算了给定整数的阶乘。

实例15：结构体数组和指针

#include <stdio.h>

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

int main() {
    Point points[2];
    Point *ptr;

    points[0].x = 1;
    points[0].y = 2;
    points[1].x = 3;
    points[1].y = 4;

    ptr = &points[0];
    printf("第一个点的坐标：%d, %d\n", ptr->x, ptr->y);
    ptr++;
    printf("第二个点的坐标：%d, %d\n", ptr->x, ptr->y);
    return 0;
}

本实例展示了如何使用结构体数组和指针来操作数据。

实例16：动态分配结构体数组

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

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

int main() {
    int num = 3;
    Point *points = (Point *)malloc(num * sizeof(Point));

    for (int i = 0; i < num; i++) {
        points[i].x = i * 2;
        points[i].y = i * 2 + 1;
    }

    for (int i = 0; i < num; i++) {
        printf("点的坐标：%d, %d\n", points[i].x, points[i].y);
    }

    free(points);
    return 0;
}

本实例展示了如何动态分配结构体数组并操作数据。

实例17：链表插入

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

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

int main() {
    Node *head = (Node *)malloc(sizeof(Node));
    Node *second = (Node *)malloc(sizeof(Node));
    Node *third = (Node *)malloc(sizeof(Node));

    head->data = 1;
    head->next = second;
    second->data = 2;
    second->next = third;
    third->data = 3;
    third->next = NULL;

    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = 4;
    newNode->next = second;

    head = newNode;

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

    free(head);
    free(second);
    free(third);
    free(newNode);
    return 0;
}

本实例演示了如何在链表的头部插入一个新节点。

实例18：链表删除

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

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

int main() {
    Node *head = (Node *)malloc(sizeof(Node));
    Node *second = (Node *)malloc(sizeof(Node));
    Node *third = (Node *)malloc(sizeof(Node));

    head->data = 1;
    head->next = second;
    second->data = 2;
    second->next = third;
    third->data = 3;
    third->next = NULL;

    Node *temp = head;
    head = head->next;
    free(temp);

    Node *current = head;
    while (current != NULL && current->next != NULL) {
        temp = current->next;
        current->next = temp->next;
        free(temp);
    }
    printf("链表元素：");
    current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");

    free(head);
    return 0;
}

本实例演示了如何在链表中删除节点。

实例19：栈操作

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

#define MAX_SIZE 10

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

void initialize(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;
    }
}

int pop(Stack *s) {
    if (!isEmpty(s)) {
        return s->data[s->top--];
    }
    return -1;
}

int main() {
    Stack s;
    initialize(&s);

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

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

    return 0;
}

本实例展示了如何使用栈结构进行元素的入栈和出栈操作。

实例20：队列操作

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

#define MAX_SIZE 10

typedef struct {
    int data[MAX_SIZE];
    int front;
    int rear;
} Queue;

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

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

int isFull(Queue *q) {
    return (q->rear + 1) % MAX_SIZE == q->front;
}

void enqueue(Queue *q, int data) {
    if (!isFull(q)) {
        q->data[q->rear] = data;
        q->rear = (q->rear + 1) % MAX_SIZE;
    }
}

int dequeue(Queue *q) {
    if (!isEmpty(q)) {
        int data = q->data[q->front];
        q->front = (q->front + 1) % MAX_SIZE;
        return data;
    }
    return -1;
}

int main() {
    Queue q;
    initialize(&q);

    enqueue(&q, 1);
    enqueue(&q, 2);
    enqueue(&q, 3);

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

    return 0;
}

本实例演示了如何使用队列结构进行元素的入队和出队操作。

实例21：快速排序

#include <stdio.h>

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

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

    return 0;
}

本实例展示了如何使用快速排序算法对数组进行排序。

实例22：归并排序

#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 mergeSort(int arr[], int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;

        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);

        merge(arr, l, m, r);
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6, 7};
    int arr_size = sizeof(arr) / sizeof(arr[0]);

    printf("给定数组：\n");
    for (int i = 0; i < arr_size; i++)
        printf("%d ", arr[i]);
    printf("\n");

    mergeSort(arr, 0, arr_size - 1);

    printf("排序后的数组：\n");
    for (int i = 0; i < arr_size; i++)
        printf("%d ", arr[i]);
    printf("\n");

    return 0;
}

本实例展示了如何使用归并排序算法对数组进行排序。

实例23：哈希表

”`c #include

#define TABLE_SIZE 10

typedef struct Node {

int data;
struct Node *next;

} Node;

Node *hashTable[TABLE_SIZE];

unsigned int hashFunction(int data) {

return data % TABLE_SIZE;

}

void insert(int data) {

unsigned int index = hashFunction(data);
Node *newNode = (Node *)malloc(sizeof(Node));
newNode->data = data;
newNode->next = hashTable[index];
hashTable[index] = newNode;

}

int search(int data) {

unsigned int index = hashFunction(data);
Node *current = hashTable[index];
while (current != NULL) {
    if (current->data == data) {
        return 1;
    }
    current = current->next;
}
return 0;

}

int main() {

int data[] = {1, 2, 11, 14, 17, 18, 19, 20, 21, 22};
int n = sizeof(data) / sizeof(data[0]);

for (int i = 0; i < n; i++) {
    insert(data[i]);
}

for (int i = 0; i < TABLE_SIZE; i++) {
    if (hashTable[i] != NULL) {
        printf("索引：%d, 数据：%d\n", i, hashTable[i]->data);
    }
}

if (search(18)) {
    printf("找到了18\n");
} else