正文

C语言中的常见容器及其实用场景详解

/0 浏览量
0330

在C语言中，虽然不像Python或Java那样有丰富的内置容器类库，但开发者仍然可以通过一些方式来模拟容器操作。以下是一些常见的C语言容器及其在编程中的实用场景。

动态数组（Dynamic Array）

定义：动态数组是一种可以动态调整大小的数组，它通常通过指针和内存分配函数（如malloc和realloc）来实现。

代码示例：

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

int main() {
    int *array = (int *)malloc(5 * sizeof(int)); // 分配初始大小
    if (array == NULL) {
        // 处理内存分配失败
        return -1;
    }

    // 初始化数组
    for (int i = 0; i < 5; ++i) {
        array[i] = i;
    }

    // 扩展数组大小
    array = (int *)realloc(array, 10 * sizeof(int));
    if (array == NULL) {
        // 处理内存分配失败
        free(array);
        return -1;
    }

    // 添加元素
    array[5] = 10;

    // 释放内存
    free(array);

    return 0;
}

实用场景：当需要处理不确定数量的数据，或者数据量可能会增加时，动态数组是一个很好的选择。例如，处理文件中的行，或者动态读取网络数据。

链表（Linked List）

定义：链表是由一系列节点组成的，每个节点包含数据和指向下一个节点的指针。

代码示例：

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

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

void insert(Node **head, int data) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = *head;
    *head = newNode;
}

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

int main() {
    Node *head = NULL;
    insert(&head, 3);
    insert(&head, 1);
    insert(&head, 2);

    printList(head);

    return 0;
}

实用场景：链表适用于插入和删除操作频繁的场景，尤其是当插入或删除操作发生在链表的中间位置时。例如，实现一个电话簿程序，或者一个任务队列。

栈（Stack）

定义：栈是一种后进先出（LIFO）的数据结构，它只有两个基本操作：push（压入）和pop（弹出）。

代码示例：

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

typedef struct Stack {
    int *array;
    int top;
    int capacity;
} Stack;

void initStack(Stack *s, int capacity) {
    s->array = (int *)malloc(capacity * sizeof(int));
    s->top = -1;
    s->capacity = capacity;
}

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

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

void push(Stack *s, int data) {
    if (isFull(s)) {
        // 处理栈满的情况
        return;
    }
    s->array[++s->top] = data;
}

int pop(Stack *s) {
    if (isEmpty(s)) {
        // 处理栈空的情况
        return -1;
    }
    return s->array[s->top--];
}

int main() {
    Stack s;
    initStack(&s, 5);

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

    printf("Popped: %d\n", pop(&s));
    printf("Popped: %d\n", pop(&s));

    return 0;
}

实用场景：栈常用于实现函数调用栈、解析器中的词法分析器等。例如，在函数调用时，使用栈来存储返回地址和局部变量。

队列（Queue）

定义：队列是一种先进先出（FIFO）的数据结构，它有两个基本操作：enqueue（入队）和dequeue（出队）。

代码示例：

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

typedef struct Queue {
    int *array;
    int front;
    int rear;
    int size;
    int capacity;
} Queue;

void initQueue(Queue *q, int capacity) {
    q->array = (int *)malloc(capacity * sizeof(int));
    q->front = 0;
    q->rear = -1;
    q->size = 0;
    q->capacity = capacity;
}

int isFull(Queue *q) {
    return q->size == q->capacity;
}

int isEmpty(Queue *q) {
    return q->size == 0;
}

void enqueue(Queue *q, int data) {
    if (isFull(q)) {
        // 处理队列满的情况
        return;
    }
    q->rear = (q->rear + 1) % q->capacity;
    q->array[q->rear] = data;
    q->size++;
}

int dequeue(Queue *q) {
    if (isEmpty(q)) {
        // 处理队列为空的情况
        return -1;
    }
    int data = q->array[q->front];
    q->front = (q->front + 1) % q->capacity;
    q->size--;
    return data;
}

int main() {
    Queue q;
    initQueue(&q, 5);

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

    printf("Dequeued: %d\n", dequeue(&q));
    printf("Dequeued: %d\n", dequeue(&q));

    return 0;
}

实用场景：队列适用于处理固定顺序的数据，例如处理打印任务、消息队列等。

总结

C语言虽然缺乏内置容器，但开发者可以通过手动实现或使用第三方库来模拟这些容器。根据不同的需求选择合适的容器，可以提高代码的效率和可读性。

-- 展开阅读全文 --