C语言-栈和队列的详解与实现

1. 栈（Stack）

栈是一种具有特定限制的线性数据结构，遵循先进后出（LIFO，Last In First Out）的原则。在栈中，只能在栈顶进行插入（push）和删除（pop）操作，访问元素的顺序是逆序的。

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

#define MAX_SIZE 100  // 假设栈的最大容量为100

// 定义栈结构
typedef struct {
    int data[MAX_SIZE];   // 存储栈元素的数组
    int top;              // 栈顶指针，指向栈顶元素的下一个位置
} Stack;

// 初始化栈
void initStack(Stack *s) {
    s->top = 0;  // 初始化栈顶指针为0，表示栈为空
}

// 判断栈是否为空
int isEmpty(Stack *s) {
    return s->top == 0;  // 栈顶指针为0表示栈为空
}

// 判断栈是否已满（针对数组实现的栈）
int isFull(Stack *s) {
    return s->top == MAX_SIZE;  // 栈顶指针达到最大容量时表示栈已满
}

// 元素入栈
void push(Stack *s, int value) {
    if (isFull(s)) {
        printf("Stack overflow! Cannot push element %d.\n", value);
        return;
    }
    s->data[s->top++] = value;  // 将元素压入栈顶后，栈顶指针加1
}

// 元素出栈
int pop(Stack *s) {
    if (isEmpty(s)) {
        printf("Stack is empty! Cannot pop element.\n");
        return -1;  // 返回一个特定值表示出错或栈空
    }
    return s->data[--s->top];  // 返回栈顶元素并将栈顶指针减1
}

// 获取栈顶元素，不删除
int top(Stack *s) {
    if (isEmpty(s)) {
        printf("Stack is empty! No top element.\n");
        return -1;  // 返回一个特定值表示出错或栈空
    }
    return s->data[s->top - 1];  // 返回栈顶元素，不修改栈顶指针
}

// 测试栈操作
int main() {
    Stack s;
    initStack(&s);

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

    printf("Top element: %d\n", top(&s));  // 应输出 3

    printf("Pop element: %d\n", pop(&s));  // 应输出 3

    printf("Top element after pop: %d\n", top(&s));  // 应输出 2

    return 0;
}

2. 队列（Queue）

队列是一种具有特定限制的线性数据结构，遵循先进先出（FIFO，First In First Out）的原则。在队列中，只能在队尾进行插入操作（enqueue），在队头进行删除操作（dequeue），访问元素的顺序是顺序的。

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

#define MAX_SIZE 100  // 假设队列的最大容量为100

// 定义队列结构
typedef struct {
    int data[MAX_SIZE];   // 存储队列元素的数组
    int front;            // 队头指针，指向队头元素
    int rear;             // 队尾指针，指向队尾元素的下一个位置
} Queue;

// 初始化队列
void initQueue(Queue *q) {
    q->front = 0;         // 初始化队头指针为0
    q->rear = 0;          // 初始化队尾指针为0
}

// 判断队列是否为空
int isEmpty(Queue *q) {
    return q->front == q->rear;  // 队头指针等于队尾指针表示队列为空
}

// 判断队列是否已满（针对数组实现的队列）
int isFull(Queue *q) {
    return (q->rear + 1) % MAX_SIZE == q->front;  // (rear+1)%MAX_SIZE 等于 front 表示队列已满
}

// 元素入队
void enqueue(Queue *q, int value) {
    if (isFull(q)) {
        printf("Queue overflow! Cannot enqueue element %d.\n", value);
        return;
    }
    q->data[q->rear] = value;       // 将元素存入队尾
    q->rear = (q->rear + 1) % MAX_SIZE;  // 更新 rear 指针，循环利用数组空间
}

// 元素出队
int dequeue(Queue *q) {
    if (isEmpty(q)) {
        printf("Queue is empty! Cannot dequeue element.\n");
        return -1;  // 返回一个特定值表示出错或队列空
    }
    int value = q->data[q->front];  // 获取队头元素
    q->front = (q->front + 1) % MAX_SIZE;  // 更新 front 指针，循环利用数组空间
    return value;  // 返回出队元素的值
}

// 获取队头元素，不删除
int front(Queue *q) {
    if (isEmpty(q)) {
        printf("Queue is empty! No front element.\n");
        return -1;  // 返回一个特定值表示出错或队列空
    }
    return q->data[q->front];  // 返回队头元素的值
}

// 测试队列操作
int main() {
    Queue q;
    initQueue(&q);

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

    printf("Front element: %d\n", front(&q));  // 应输出 1

    printf("Dequeue element: %d\n", dequeue(&q));  // 应输出 1

    printf("Front element after dequeue: %d\n", front(&q));  // 应输出 2

    return 0;
}

时间复杂度分析：

• 栈的操作时间复杂度：

  • push 和 pop 操作的时间复杂度为 O(1)。
  • top 操作的时间复杂度为 O(1)。
  • isEmpty 操作的时间复杂度为 O(1)。

• 队列的操作时间复杂度：

  • enqueue 和 dequeue 操作的时间复杂度为 O(1)。
  • front 操作的时间复杂度为 O(1)。
  • isEmpty 操作的时间复杂度为 O(1)。

这些操作的时间复杂度都很低，使得栈和队列在实际应用中具有高效的性能表现。