C语言链表实现队列和栈：探索数据结构的灵活运用

标题：C语言链表实现队列和栈：探索数据结构的灵活运用

导言

队列和栈是常见的数据结构，它们在算法和系统设计中有着广泛的应用。本技术教程将使用C语言中的链表实现队列和栈，详细讲解实现过程，并附上完整的代码示例。通过学习本文，读者将深入理解链表的灵活性和在队列和栈中的应用。

1. 链表定义

在开始实现队列和栈之前，我们首先定义链表的结构：

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

// 链表节点定义
struct Node {
    int data;
    struct Node* next;
};

2. 链表实现队列

2.1 队列结构定义

struct Queue {
    struct Node* front;
    struct Node* rear;
};

2.2 队列操作函数

// 初始化队列
struct Queue* initializeQueue() {
    struct Queue* q = (struct Queue*)malloc(sizeof(struct Queue));
    q->front = q->rear = NULL;
    return q;
}

// 入队操作
void enqueue(struct Queue* q, int newData) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = newData;
    newNode->next = NULL;

    if (q->rear == NULL) {
        q->front = q->rear = newNode;
        return;
    }

    q->rear->next = newNode;
    q->rear = newNode;
}

// 出队操作
int dequeue(struct Queue* q) {
    if (q->front == NULL)
        return -1; // 空队列

    int data = q->front->data;
    struct Node* temp = q->front;

    q->front = q->front->next;

    if (q->front == NULL)
        q->rear = NULL;

    free(temp);
    return data;
}

// 销毁队列
void destroyQueue(struct Queue* q) {
    while (q->front != NULL) {
        dequeue(q);
    }
    free(q);
}

3. 链表实现栈

3.1 栈结构定义

struct Stack {
    struct Node* top;
};

3.2 栈操作函数

// 初始化栈
struct Stack* initializeStack() {
    struct Stack* s = (struct Stack*)malloc(sizeof(struct Stack));
    s->top = NULL;
    return s;
}

// 入栈操作
void push(struct Stack* s, int newData) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = newData;
    newNode->next = s->top;
    s->top = newNode;
}

// 出栈操作
int pop(struct Stack* s) {
    if (s->top == NULL)
        return -1; // 空栈

    int data = s->top->data;
    struct Node* temp = s->top;
    s->top = s->top->next;
    free(temp);

    return data;
}

// 销毁栈
void destroyStack(struct Stack* s) {
    while (s->top != NULL) {
        pop(s);
    }
    free(s);
}

4. 示例代码

4.1 队列的使用

int main() {
    struct Queue* myQueue = initializeQueue();

    enqueue(myQueue, 10);
    enqueue(myQueue, 20);
    enqueue(myQueue, 30);

    printf("Dequeue: %d\n", dequeue(myQueue));
    printf("Dequeue: %d\n", dequeue(myQueue));

    destroyQueue(myQueue);

    return 0;
}

4.2 栈的使用

int main() {
    struct Stack* myStack = initializeStack();

    push(myStack, 10);
    push(myStack, 20);
    push(myStack, 30);

    printf("Pop: %d\n", pop(myStack));
    printf("Pop: %d\n", pop(myStack));

    destroyStack(myStack);

    return 0;
}