深入浅出数据结构：堆栈与队列的奇幻之旅

最新推荐文章于 2024-09-10 18:20:25 发布

安大小万

最新推荐文章于 2024-09-10 18:20:25 发布

阅读量427

点赞数 6

分类专栏：数据结构文章标签：数据结构算法

本文链接：https://blog.csdn.net/wgr050505/article/details/136406814

版权

数据结构专栏收录该内容

8 篇文章 0 订阅

订阅专栏

引言：揭秘线性数据结构的秘密花园

在计算机科学的世界里，堆栈与队列就如同魔法师手中的神器，以简洁而强大的规则塑造着程序的脉络。这两种线性数据结构，分别遵循着后进先出（LIFO）和先进先出（FIFO）的原则，极大地简化了诸如函数调用、任务调度等多种复杂场景下的问题解决过程。

第一部分：堆栈的魔力探寻

1.1 堆栈的概念与特性

堆栈是一种限制性的数据结构，就像一个倒置的桶，最后放入的东西第一个被拿出来，这便是“后进先出”的原则。

1.2 C语言实现堆栈

1.2.1 定义堆栈结构体

1typedef struct Stack {
2    int capacity;  // 堆栈容量
3    int top;       // 栈顶指针
4    int* array;    // 存储元素的数组
5} Stack;

1.2.2 堆栈操作实现

初始化堆栈

1Stack* createStack(int capacity) {
2    Stack* stack = (Stack*)malloc(sizeof(Stack));
3    stack->capacity = capacity;
4    stack->top = -1;
5    stack->array = (int*)malloc(capacity * sizeof(int));
6    return stack;
7}

入栈（Push）操作

1void push(Stack* stack, int item) {
2    if (stack->top >= stack->capacity - 1) {
3        printf("Stack Overflow!\n");
4        return;
5    }
6    stack->array[++stack->top] = item;
7}

出栈（Pop）操作

1int pop(Stack* stack) {
2    if (stack->top < 0) {
3        printf("Stack Underflow!\n");
4        return INT_MIN;
5    }
6    return stack->array[stack->top--];
7}

查看栈顶元素（Peek）

1int peek(Stack* stack) {
2    if (stack->top < 0) {
3        printf("Stack is empty!\n");
4        return INT_MIN;
5    }
6    return stack->array[stack->top];
7}

1.3 堆栈的应用实例

函数调用栈的模拟
字符串逆序输出
表达式求值等

第二部分：队列的韵律节奏

2.1 队列的概念与特性

队列则像是生活中常见的排队现象，先进去的人先出来，即“先进先出”原则。

2.2 C语言实现队列

2.2.1 定义队列结构体

1typedef struct Queue {
2    int front;     // 队首指针
3    int rear;      // 队尾指针
4    int capacity;  // 队列容量
5    int* array;    // 存储元素的数组
6} Queue;

2.2.2 队列操作实现

初始化队列

1Queue* createQueue(int capacity) {
2    Queue* queue = (Queue*)malloc(sizeof(Queue));
3    queue->capacity = capacity;
4    queue->front = queue->rear = -1;
5    queue->array = (int*)malloc(capacity * sizeof(int));
6    return queue;
7}

入队（Enqueue）操作

1void enqueue(Queue* queue, int item) {
2    if (queue->rear >= queue->capacity - 1) {
3        printf("Queue Overflow!\n");
4        return;
5    }
6    queue->array[++queue->rear] = item;
7    if (queue->front == -1)
8        queue->front = 0;
9}

出队（Dequeue）操作

1int dequeue(Queue* queue) {
2    if (queue->front == -1 || queue->front > queue->rear) {
3        printf("Queue Underflow!\n");
4        return INT_MIN;
5    }
6    int item = queue->array[queue->front];
7    queue->front = (queue->front + 1) % queue->capacity;
8    return item;
9}

查看队首元素（Front）

1int front(Queue* queue) {
2    if (queue->front == -1 || queue->front > queue->rear) {
3        printf("Queue is empty!\n");
4        return INT_MIN;
5    }
6    return queue->array[queue->front];
7}