栈与队列的实现

最新推荐文章于 2026-06-17 23:49:13 发布
原创 最新推荐文章于 2026-06-17 23:49:13 发布 · 986 阅读 · 13 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#算法

栈与队列的实现

栈

后进先出：插入与删除操作都在栈顶

数组实现栈

核心思想

  • 使用一数组存储栈元素（例如 A ），栈顶指针 top 记录栈顶元素的索引。

  • 将 top 初始化为 -1 ，表示栈为空。

  • 通过对索引的加减等操作，实现入栈、出栈等操作

核心操作

  • push(x) : 入栈

    push(x){
    top = top + 1;   //栈顶指针+1
    A[top] = x;
}

  • pop() : 出栈

    pop(){
    if(top == -1) {  // 栈空判断
        printf("No element to pop \n");
        return;
    }
    top = top - 1;  /*栈顶指针减 1，直接将索引向前移一位，不用清除此处的数据，因为下次给此处赋值时会覆盖掉上次的数据*/
}

  • top() : 获取栈顶元素的值（不删除）

    Top（）{
    return A[top];  //直接返回栈顶元素的值
}

  • IsEmpty() : 判断栈是否为空

    int IsEmpty(){
    if(top == -1){
        return true;
    }else{
        return false;
    }
}

溢出问题及解决

  • 当数组已满（top == 数组长度 - 1）时，继续入栈则会触发栈溢出

  • 解决方案：创建更大的数组，将原来数组内所有元素复制到新数组（ 新数组 一般为 原数组 的两倍）

代码实现
#include<stdio.h>
#define MAX_SIZE 101  // 定义栈的最大容量
int A[MAX_SIZE];     // 用数组A存储栈元素
int top = -1;        // 栈顶指针，初始为-1表示栈空
​
// 入栈操作：将元素x压入栈顶
void Push(int x) {
    if(top == MAX_SIZE - 1) {  // 栈满判断
        printf(" stack overflow \n");
        return;
    }
    A[++top] = x;  // 栈顶指针先加1，再存入元素
}
​
// 出栈操作：从栈顶弹出一个元素
void Pop() {
    if(top == -1) {  // 栈空判断
        printf("No element to pop \n");
        return;
    }
    top--;  //栈顶指针减1
}
​
// 获取栈顶元素
int Top() {
    if(top == -1) {
        printf("栈为空\n");
        return -1;
    }
    return A[top];
}
​
// 使用示例（可根据需求调用上述操作）
int main() {
    Push(10);
    Push(20);
    printf("栈顶元素：%d\n", Top());
    Pop();
    printf("出栈后栈顶元素：%d\n", Top());
    return 0;
}

上述实现简单直观，但也存在一些 缺点：

  • 不能在一个程序中创建多个栈

  • 大小固定，无法动态调整

因此更好的方法是通过 结构体 来实现：

  • 可将栈的状态封装在结构体中

    • 为什么要封装：

      • 将相关的数据组织在一起

      • 隐藏内部实现细节

      • 提供统一的接口操作

  • 可创建多个独立的栈

  • 可根据需要自动调整大小

    #include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
​
#define INIT_CAPACITY 10
​
typedef struct {
    int *data;      //动态数组指针
    int top;        //栈顶指针
    int capacity;   //当前容量
}ArrayStack;
​
//创建栈：在堆上分配内存
ArrayStack* creat_ArrayStack() {
    ArrayStack* stack = (ArrayStack*)malloc(sizeof(Arraystack));   //分配栈结构体本身的内存
    stack->data = (int*)malloc(sizeof(int) * INIT_CAPACITY);      //分配数据数组的内存
    //初始化其他
    stack->top = -1;
    stack->capacity = INIT_CAPACITY;
    return stack;
}
​
//判断栈是否为空
bool IsEmpty(Arraystack* stack) {
    return stack->top == -1;
}
​
//判断栈是否已满
bool IsFull(ArrayStack* stack) {
    return stack->top == stack->capacity - 1;
}
​
//扩容
void resize_ArrayStack(ArrayStack* stack) {
    int newCapacity = stack->capacity * 2;
    int* newData = (int*)malloc(sizeof(int) * newCapacity);
    
    for(int i = 0; i <= stack->top; i++) {    //将原数组复制到新数组
        newData[i] = stack->data[i];
    }
    
    free(stack->data);
    stack->data = newData;
    stack->capacity = newCapacity;
    printf("已扩容，新容量：%d\n", newCacity);
}
​
//入栈
void push(ArrayStack* stack, int val) {
    if (IsFull(stack)) {
        resize_ArrayStack(stack);
    }
    stack->data[++stack->top] = val;
}
​
//出栈
int pop(ArrayStack* stack) {
    if (IsEmpty(stack)) {
        printf("栈为空，无法出栈\n");
        return -1;
    }
    return stack->data[stack->top--];   //返回被弹出的数，并将栈顶指针减 1
}
​
//查看栈顶元素
int Top(ArrayStack* stack){
    if (IsEmpty(stack)) {
        printf("栈为空\n");
        return -1;
    }
    return stack->data[stack->top];
}
​
//获取栈大小
int Size(ArrayStack *stack) {
    return stack->top + 1;
}
​
//打印栈
void print_ArrayStack(ArrayStack *stack) {
    if (IsEmpty(stack)) {
        printf("栈: []\n");
        return;
    } 
    printf("栈: [");
    for (int i = 0; i <= stack->top; i++) {
        printf("%d", stack->data[i]);
        if (i < stack->top) printf(", ");
    }
    printf("]\n");
}
​
//释放栈
void free_ArrayStack(ArrayStack* stack) {
    free(stack->data);    //释放前边为数组分配的内存
    free(stack);         //释放前边为结构体本身分配的内存
}

链表实现栈

核心思想

  • 链表实现栈时，以链表头部作为栈顶，所有操作都在头部进行

  • 入栈：创建新节点，指针域指向原栈顶节点，再将栈顶指针指向新节点

  • 出栈：将栈顶指针向后移一位，释放原栈顶节点

代码实现
//链表节点的定义
typedef struct ListNode {
    int val;
    struct ListNode* next;
} ListNode;
​
// 创建新节点
ListNode* createNode(int value) {
    ListNode* node = (ListNode*)malloc(sizeof(ListNode));
    node->val = value;
    node->next = NULL;
    return node;
}
​
​
//链表实现栈
typedef struct {
    ListNode* top;
    int size;
} LinkedStack;
​
// 初始化栈
LinkedStack* create_LinkedStack() {
    LinkedStack* stack = (LinkedStack*)malloc(sizeof(LinkedStack));
    stack->top = NULL;
    stack->size = 0;
    return stack;
}
​
// 判断栈是否为空
bool IsEmpty(LinkedStack* stack) {
    return stack->top == NULL;
}
​
// 入栈
void Push(LinkedStack* stack, int value) {
    ListNode* newNode = createNode(value);
    newNode->next = stack->top;
    stack->top = newNode;
    stack->size++;
}
​
// 出栈
int Pop(LinkedStack* stack) {
    if (IsEmpty(stack)) {
        printf("栈为空，无法出栈\n");
        return -1;
    }
    
    ListNode* temp = stack->top;
    int value = temp->val;
    stack->top = stack->top->next;
    free(temp);
    stack->size--;
    return value;
}
​
// 查看栈顶元素
int Top(LinkedStack* stack) {
    if (IsEmpty(stack)) {
        printf("栈为空\n");
        return -1;
    }
    return stack->top->val;
}
​
// 获取栈大小
int Size(LinkedStack* stack) {
    return stack->size;
}
​
// 打印栈
void print_LinkedStack(LinkedStack* stack) {
    if (IsEmpty(stack)) {
        printf("栈: []\n");
        return;
    }
    
    printf("栈: [");
    ListNode *current = stack->top;
    while (current != NULL) {
        printf("%d", current->val);
        if (current->next != NULL) printf(", ");
        current = current->next;
    }
    printf("]\n");
}
​
// 释放栈
void free_LinkedStack(LinkedStack* stack) {
    while (!IsEmpty(stack)) {
        Pop(stack);
    }
    free(stack);
}

队列

先进先出：队尾进入，队首离开

数组实现队列

核心思想

  • 设置两个索引分别代表队首（front）和队尾（rear），二者都为 -1 时表示队列为空

  • 队列的长度为 front 和 rear 之间的长度

  • 入队：将 rear后移一位，给该处赋值

    • 当数组最后填满而前面空间仍有剩余时，可以使用循环数组实现对该空间的利用：(queue->front + i) % queue->capacity

  • 出队：将 front 后移一位

代码实现
typedef struct {
    int* data;
    int front;
    int rear;
    int size;
    int capacity;
} ArrayQueue;
​
// 初始化队列
ArrayQueue* create_ArrayQueue() {
    ArrayQueue* queue = (ArrayQueue*)malloc(sizeof(ArrayQueue));
    queue->capacity = INIT_CAPACITY;
    queue->data = (int*)malloc(sizeof(int) * queue->capacity);
    queue->front = 0;
    queue->rear = 0;
    queue->size = 0;
    return queue;
}
​
// 判断队列是否为空
bool IsEmpty(ArrayQueue* queue) {
    return queue->size == 0;
}
​
// 判断队列是否已满
bool IsFull(ArrayQueue* queue) {
    return queue->size == queue->capacity;
}
​
// 扩容
void resize_ArrayQueue(ArrayQueue* queue) {
    int newCapacity = queue->capacity * 2;
    int* newData = (int*)malloc(sizeof(int) * newCapacity);
    
    // 将原队列元素复制到新队列
    for (int i = 0; i < queue->size; i++) {
        newData[i] = queue->data[(queue->front + i) % queue->capacity];
    }
    
    free(queue->data);
    queue->data = newData;
    queue->front = 0;
    queue->rear = queue->size;
    queue->capacity = newCapacity;
    printf("队列已扩容，新容量: %d\n", newCapacity);
}
​
// 入队
void Enqueue(ArrayQueue* queue, int value) {
    if (IsFull(queue)) {
        resizeArrayQueue(queue);
    }
    queue->data[queue->rear] = value;
    queue->rear = (queue->rear + 1) % queue->capacity;
    queue->size++;
}
​
// 出队
int Dequeue(ArrayQueue* queue) {
    if (IsEmpty(queue)) {
        printf("队列为空，无法出队\n");
        return -1;
    }
    int value = queue->data[queue->front];
    queue->front = (queue->front + 1) % queue->capacity;
    queue->size--;
    return value;
}
​
// 查看队头元素
int Front(ArrayQueue* queue) {
    if (IsEmpty(queue)) {
        printf("队列为空\n");
        return -1;
    }
    return queue->data[queue->front];
}
​
// 获取队列大小
int Size(ArrayQueue* queue) {
    return queue->size;
}
​
// 打印队列
void print_ArrayQueue(ArrayQueue* queue) {
    if (IsEmpty(queue)) {
        printf("队列: []\n");
        return;
    }
    
    printf("队列: [");
    for (int i = 0; i < queue->size; i++) {
        printf("%d", queue->data[(queue->front + i) % queue->capacity]);
        if (i < queue->size - 1) printf(", ");
    }
    printf("]\n");
}
​
// 释放队列
void free_ArrayQueue(ArrayQueue* queue) {
    free(queue->data);
    free(queue);
}

链表实现队列

核心思想

  • 使用两个指针 front 和 rear 分别指向链表的头部和尾部

  • 入队：使原尾节点指向新节点，再使 rear 指向新节点

  • 出队：将 front 后移一位，并释放原头节点

代码实现
//定义链表节点
typedef struct ListNode {
    int val;
    struct ListNode* next;
} ListNode;
​
// 创建新节点
ListNode* createNode(int value) {
    ListNode* node = (ListNode*)malloc(sizeof(ListNode));
    node->val = value;
    node->next = NULL;
    return node;
}
​
​
//链表实现队列
typedef struct {
    ListNode* front;
    ListNode* rear;
    int size;
} LinkedQueue;
​
// 初始化队列
LinkedQueue* create_LinkedQueue() {
    LinkedQueue* queue = (LinkedQueue*)malloc(sizeof(LinkedQueue));
    queue->front = NULL;
    queue->rear = NULL;
    queue->size = 0;
    return queue;
}
​
// 判断队列是否为空
bool IsEmpty(LinkedQueue* queue) {
    return queue->front == NULL;
}
​
// 入队
void Enqueue(LinkedQueue* queue, int value) {
    ListNode* newNode = createNode(value);
    
    if (IsEmpty(queue)) {
        queue->front = queue->rear = newNode;
    } else {
        queue->rear->next = newNode;
        queue->rear = newNode;
    }
    queue->size++;
}
​
// 出队
int Dequeue(LinkedQueue* queue) {
    if (IsEmpty(queue)) {
        printf("队列为空，无法出队\n");
        return -1;
    }
    
    ListNode* temp = queue->front;
    int value = temp->val;
    queue->front = queue->front->next;
    
    // 如果出队后队列为空，需要更新rear指针
    if (queue->front == NULL) {
        queue->rear = NULL;
    }
    
    free(temp);
    queue->size--;
    return value;
}
​
// 查看队头元素
int Front(LinkedQueue* queue) {
    if (IsEmpty(queue)) {
        printf("队列为空\n");
        return -1;
    }
    return queue->front->val;
}
​
// 获取队列大小
int Size(LinkedQueue* queue) {
    return queue->size;
}
​
// 打印队列
void print_LinkedQueue(LinkedQueue* queue) {
    if (IsEmpty(queue)) {
        printf("队列: []\n");
        return;
    }
    
    printf("队列: [");
    ListNode *current = queue->front;
    while (current != NULL) {
        printf("%d", current->val);
        if (current->next != NULL) printf(", ");
        current = current->next;
    }
    printf("]\n");
}
​
// 释放队列
void free_LinkedQueue(LinkedQueue* queue) {
    while (!IsEmpty(queue)) {
        Dequeue(queue);
    }
    free(queue);
}
wlsh15
关注
栈实现队列与队列实现堆
2302_80318761的博客
07-05 1039
好了，以上就是关于栈与队列相互实现的相关知识吧。当然这些有其中有很多可以优化的地方，大家可以细心的观察一下，然后呢其中关于这个博客大家其实可以相当于课后拓展，因为确实这样没必要把他作为一个非常重要知识点，大家只需要知道如何使用就可以了。最主要的还是需要大家熟练使用对业余战的单个的相关知识来，希望这篇不太对大家会有帮助，然后今天的讲解就到这里了。
数据结构——栈与队列的实现与相互实现
IridescentLife的博客
05-29 778
本文系统讲解了栈和队列的概念及实现方法。栈采用动态数组实现，支持初始化、扩容、入栈出栈等操作；队列采用链表结构实现，包含初始化、入队出队等接口。重点探讨了两种数据结构相互转换的方法：1）使用两个栈实现队列功能，通过元素倒换实现FIFO特性；2）用两个队列模拟栈操作，采用轮流倒换队列的方式实现LIFO。同时介绍了循环队列的实现策略，通过多开辟一个空间解决判空/满问题。文中详细给出了各数据结构的接口代码实现，并配有示意图辅助理解，为掌握这些基础数据结构及其转换应用提供了清晰指导。
栈与队列以及其实现
2401_84040384的博客
09-22 784
栈（Stack）遵循先进后出（Last In First Out）原则，类似生活中 “叠盘子”—— 最后放的盘子先被拿走，最底层的盘子最后才能取到。栈顶（Top）：允许插入和删除操作的一端（类比最上层的盘子）；栈底（Bottom）：固定不动、不允许操作的一端（类比最底层的盘子）；基本操作：push（入栈，添加元素到栈顶）、pop（出栈，移除栈顶元素）、peek（查看栈顶元素，不删除）、isEmpty（判断栈是否为空）。队列（Queue）遵循先进先出（First In First Out）
队列与栈之间的灵魂转换——用栈实现队列、用队列实现栈
DEXTERFUTIAN的博客
08-25 208
队列与栈是怎么相互转换的？？？ 图文超详细讲解！！！
哈夫曼树
Queenie_Charlie 的博客
06-13 280
实际上，哈夫曼算法的实现与实际问题所采用的存储结构有关。现假设用数组F来存储哈夫曼树，其中第i个数组元素F[i]是哈夫曼树中的一个结点，其地址为i，有3个域，Data域存放该结点的权值，lChild域和rChild域分别存放该结点左、右子树的根结点的地址（下标）。在以后每步构造一棵新二叉树时，都需要对森林中所有二叉树的根结点进行排序，因此可用数组a作为排序暂存空间，其中第i个数组元素a[i]是森林F中第i棵二叉树的根结点，有2个域，Data是根结点所对应的权值，Addr是根结点在F中的地址（下标）。
2026年第九届GXCPC广西大学生程序设计大赛（热身赛）题解
奇妙方程式的博客
06-15 246
题目来源：未知，可在评论区补充。
百度 C++/PHP 研发一二面：一面扫八股和算法，二面开始逼近 Redis、MySQL 和秒杀设计
TechPioneer_lp的博客
06-15 199
这篇百度C++/PHP研发面经展现了后端岗位的面试进阶路径：一面侧重算法、操作系统、网络等基础（如链表判环、HTTP协议），二面则深入Redis/MySQL底层、高并发设计（如秒杀系统）。面经揭示百度筛选标准：基础合格后，重点考察缓存/数据库系统理解、高并发设计能力。建议准备时：一面夯实算法和语言基础（C++关键字/多态），二面吃透Redis/MySQL原理，并构建系统设计思维。笔试不佳仍有面试机会，但二面才是真正的能力分水岭。
《LeetCode 200 FloodFill 岛屿数量DFS解法》
2601_95366422的博客
06-15 269
LeetCode200 岛屿数量
C语言学习笔记 - 55.流程控制9 - 选择5 - if...else if多分支语句
weixin_57913829的博客
06-17 284
本文介绍了C语言中if-elseif多分支语句的核心概念和应用。该语句专门用于处理多个互斥条件的选择问题，通过自上而下依次判断表达式，从多个分支中选择且仅执行一个语句块。文章详细阐述了语法格式、执行逻辑，并提供了成绩等级划分和一元二次方程求解两个典型示例。同时指出了常见错误，如条件判断顺序错误、单独的else语句等，并对比了if-elseif与嵌套if语句的优劣，强调前者在代码简洁性和可读性方面的优势。
[LC优选算法#5] 分治:快排 | 颜色分类 | 排序数组 | 第K大元素
C++开发
06-14 354
本文介绍了基于分治思想的快速排序算法及其应用。主要内容包括：1) 分治快排与普通快排的区别，分治快排将数组分为三部分，解决了全为key值时效率退化问题；2) 通过颜色分类、排序数组和求第K大元素三个例题，详细讲解分治快排的实现和优化技巧，如随机选择基准元素；3) 特别分析了TopK问题的解法，如何在排序过程中通过区间元素数量比较快速定位目标元素。文章提供了清晰的算法图解和代码实现，展示了分治快排算法在稳定O(NlogN)时间复杂度上的优势。
芝士算法（滑动窗口片 2.0）
AKA__Zas的博客
06-13 107
因为数组只存在 ’数字串‘ 所以也可以使用数组建立哈希表 kinds 表示。题目给出了类型 要求出个数 使用。此题本质上 和 上题 没有大致区别。1）字符串 要每一小短对应 len。简单的说这一道题 从数组串要求出。的存在所以要对部分做出修改。（数组有多少个小段字符串）pluspro 加强版。
LeetCode 3264.K次乘运算后的最终数组I
tus00000的博客
06-17 221
如果nums的大小为n，数组中最大值为U，multiplier为m，则此算法时间复杂度为O(nlognlog。输入：nums = [2,1,3,5,6], k = 5, multiplier = 2。输入：nums = [1,2], k = 3, multiplier = 4。1 次操作后 [2, 2, 3, 5, 6]2 次操作后 [4, 2, 3, 5, 6]3 次操作后 [4, 4, 3, 5, 6]4 次操作后 [4, 4, 6, 5, 6]5 次操作后 [8, 4, 6, 5, 6]
滑动窗口最大值问题：单调队列的巧妙应用
纳兰青华的博客
06-16 327
本文介绍了使用单调队列高效解决滑动窗口最大值问题的方法。通过维护一个单调递减的双端队列存储元素索引，算法能在O(n)时间复杂度内找到每个窗口的最大值。关键步骤包括：1)维护队列单调性，移除小于新元素的队尾元素；2)检查队首元素是否超出窗口范围；3)当窗口形成时记录队首最大值。相比暴力解法的O(n×w)复杂度，这种优化方案显著提升了效率，特别适合处理大规模数据。文章结合示例详细演示了算法执行过程，并分析了复杂度，最后总结了单调队列在滑动窗口问题中的通用性。
算法总结（链表、哈希）
最新发布
2503_93247646的博客
06-17 620
在文章的最后，还有一个细节需要被提及，就是虚拟头节点。无论是我们构建链表，还是做链表的算法题也好，虚拟头节点一直是我们无法回避的一个点，不是说没有虚拟头节点我们做不了，而是可以更加的方便，可以把所有的操作全部统一而且不需要考虑空链表报错的情况本篇文章就到这里结束了，希望可以对大家有所帮助~~~
需求预测终极指南：零售商品预测方法、算法与AI实践
06-16 395
需求预测（Demand Forecasting）是零售企业利用历史销售数据、市场趋势、促销计划、季节性规律和外部环境因素，通过统计模型或机器学习算法，对未来特定时间段内各SKU销售量进行系统性预测的过程。区分需求预测与相关概念：需求预测关注数量维度（预测卖多少件），销售预测关注金额维度（预测卖多少钱），两者相乘得到销售金额预测，共同构成商品预算的数据基础。需求预测不等于销售目标——目标是战略性设定，预测是数据驱动的量化估算，两者可以不同，不应强制对齐。
算法札记：归并排序
Keven_11的博客
06-16 196
摘要：本文对比了归并排序与快速排序的特性。归并排序稳定，时间复杂度稳定为O(nlogn)，但需要额外空间；快速排序不稳定，平均复杂度O(nlogn)，最坏O(n²)，但空间效率高且缓存友好。实际应用中，快排因优化技术（如三数取中）更常用，而归并排序在需要稳定性、外部排序和链表排序等场景不可替代。现代语言常采用混合策略兼顾二者优点。理解两种算法的适用场景对实际编程选型至关重要。（149字）
BP神经网络用什么训练算法(traingd、traingdm、trainlm)
dbat
06-14 209
在使用matlab来训练BP神经网络时，我们不免会疑惑，究竟要怎么选择训练函数呢？
算法札记：模拟栈、模拟队列
Keven_11的博客
06-17 250
在算法竞赛中，数组模拟数据结构往往比STL容器更具优势。数组模拟栈（用tt指针）和队列（用hh/tt指针）能显著提升性能，避免TLE，且支持清空、遍历等灵活操作。其核心代码简洁（约5行），在NOIP等竞赛中已成惯例。而priority_queue等复杂结构仍建议使用STL。选择依据：大数据量/关键比赛用手写，小数据量/O2优化环境下可用STL。这种优化策略源自竞赛圈实践，由"豆包"等大神总结推广。（149字）
2021年CSP-X复赛真题及题解（T3：口袋）
王老师青少年编程
06-17 475
2021年CSP-X复赛真题及题解（T3：口袋）
强化学习Option框架：从理论到算法实施流程
qq_21493823的博客
06-15 830
Option框架是分层强化学习主流时间抽象框架，由Sutton团队1999年顶会论文提出，依托SMDP理论突破传统MDP单步动作决策局限，借助时序抽象子任务解决长时序、稀疏奖励类复杂强化学习难题。本文依托该框架基础理论与三元组数学定义，梳理原生Option、Option-Critic及衍生算法原理，拆解标准化算法实施流程，结合工程优化策略、训练缺陷与前沿改进方向，系统完成Option框架从底层理论、核心算法到工程落地的全维度梳理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值