程序员常用的几种数据结构在C语言中的详解与代码实践

目录

1. 数组（Array）

2. 链表（Linked List）

3. 栈（Stack）

4. 队列（Queue）

---

在计算机科学和软件开发中，数据结构是对数据进行有效组织和管理的关键。它们不仅是算法设计的基础，也是优化程序性能的核心要素。本文将全面深入地介绍四种程序员常用的C语言数据结构：数组、链表、栈和队列，同时配以详细的代码示例，帮助读者理解和掌握这些基础数据结构的实现和应用。

1. 数组（Array）

数组是一种最基本的数据结构，它是在内存中开辟一段连续空间来存储相同类型元素的集合。每个元素通过索引访问，索引通常是整数形式，表示元素在数组中的位置。

1#include <stdio.h>
2
3// 定义一个大小为5的整型数组
4int arr[5];
5
6// 初始化数组元素
7void initArray() {
8    for(int i = 0; i < 5; i++) {
9        arr[i] = i * 10; // 将i*10的值存入数组对应位置
10    }
11}
12
13int main() {
14    initArray();
15    // 输出数组元素
16    for(int i = 0; i < 5; i++) {
17        printf("arr[%d]: %d\n", i, arr[i]); // 输出数组元素的索引和值
18    }
19    return 0;
20}

数组的主要优点是随机访问速度快，但其长度一旦定义就不能动态改变，而且插入和删除元素往往需要大量元素移动。

2. 链表（Linked List）

链表是一种动态数据结构，它由一系列节点组成，每个节点包含数据字段和指向下一个节点的指针。链表可以灵活地进行元素的插入和删除，无需移动其他元素。

1#include <stdio.h>
2#include <stdlib.h>
3
4typedef struct Node {
5    int data; // 数据字段
6    struct Node* next; // 指向下一个节点的指针
7} Node;
8
9// 创建新节点并初始化
10Node* createNode(int value) {
11    Node* newNode = (Node*)malloc(sizeof(Node)); // 动态分配内存
12    if(newNode == NULL) {
13        printf("Memory allocation failed.\n");
14        return NULL;
15    }
16    newNode->data = value;
17    newNode->next = NULL;
18    return newNode;
19}
20
21// 向链表尾部插入节点
22void insertNode(Node** head, int value) {
23    Node* newNode = createNode(value);
24    if(*head == NULL) {
25        *head = newNode;
26    } else {
27        Node* temp = *head;
28        while(temp->next != NULL) {
29            temp = temp->next;
30        }
31        temp->next = newNode;
32    }
33}
34
35int main() {
36    Node* head = NULL;
37    insertNode(&head, 10); // 插入第一个节点
38    insertNode(&head, 20); // 插入第二个节点
39    // ...继续插入更多节点...
40    return 0;
41}

链表的访问速度取决于其当前节点到所需节点的距离，即时间复杂度为O(n)，但其插入和删除操作通常比数组更快。

3. 栈（Stack）

栈是一种遵循后进先出（Last In First Out, LIFO）原则的线性数据结构。可以采用数组或链表实现，这里使用数组作为示例。

1#include <stdio.h>
2#include <stdlib.h>
3
4#define MAX_STACK_SIZE 100
5
6typedef struct Stack {
7    int items[MAX_STACK_SIZE]; // 存储栈元素的数组
8    int top; // 栈顶指针
9} Stack;
10
11// 初始化栈
12void initStack(Stack* stack) {
13    stack->top = -1; // 栈空时，栈顶指针设为-1
14}
15
16// 入栈操作
17void push(Stack* stack, int item) {
18    if(stack->top >= (MAX_STACK_SIZE - 1)) {
19        printf("Stack Overflow!\n");
20        return;
21    }
22    stack->top++; // 栈顶指针向上移动
23    stack->items[stack->top] = item; // 将元素放入栈顶
24}
25
26// 出栈操作
27int pop(Stack* stack) {
28    if(stack->top < 0) {
29        printf("Stack Underflow!\n");
30        return -1; // 栈空时返回特殊值
31    }
32    int item = stack->items[stack->top]; // 获取栈顶元素
33    stack->top--; // 栈顶指针向下移动
34    return item;
35}
36
37int main() {
38    Stack s;
39    initStack(&s);
40    push(&s, 5); // 入栈操作
41    push(&s, 10); // 入栈操作
42    printf("Popped item: %d\n", pop(&s)); // 出栈操作
43    return 0;
44}

4. 队列（Queue）

队列是一种遵循先进先出（First In First Out, FIFO）原则的线性数据结构，也可以通过数组或链表实现。以下为基于数组实现的循环队列示例：

1#include <stdio.h>
2#include <stdlib.h>
3
4#define MAX_QUEUE_SIZE 100
5
6typedef struct Queue {
7    int items[MAX_QUEUE_SIZE]; // 存储队列元素的数组
8    int front; // 队首指针
9    int rear; // 队尾指针
10} Queue;
11
12// 初始化队列
13void initQueue(Queue* queue) {
14    queue->front = queue->rear = -1; // 队列空时，队首和队尾指针设为-1
15}
16
17// 入队操作
18void enqueue(Queue* queue, int item) {
19    if((queue->rear + 1) % MAX_QUEUE_SIZE == queue->front) {
20        printf("Queue is Full!\n");
21        return;
22    }
23    queue->rear = (queue->rear + 1) % MAX_QUEUE_SIZE; // 更新队尾指针
24    queue->items[queue->rear] = item; // 插入元素
25    if(queue->front == -1)
26        queue->front = 0; // 若队列先前为空，初始化队首指针
27}
28
29// 出队操作
30int dequeue(Queue* queue) {
31    if(queue->front == -1 || queue->front == queue->rear + 1) {
32        printf("Queue is Empty!\n");
33        return -1; // 队列空时返回特殊值
34    }
35    int item = queue->items[queue->front]; // 获取队首元素
36    queue->front = (queue->front + 1) % MAX_QUEUE_SIZE; // 更新队首指针
37    return item;
38}
39
40int main() {
41    Queue q;
42    initQueue(&q);
43    enqueue(&q, 5); // 入队操作
44    enqueue(&q, 10); // 入队操作
45    printf("Dequeued item: %d\n", dequeue(&q)); // 出队操作
46    return 0;
47}

以上四种数据结构是编程中不可或缺的基础元素，掌握它们的原理和实现将有助于程序员在面对复杂问题时，设计出更为高效、合理的解决方案。