栈和队列详解（含代码演示）

已于 2022-05-08 18:49:12 修改
阅读量774 收藏 4
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 数据结构 c算法 链表 c++
于 2022-04-27 18:05:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Guqing_f/article/details/124457106
版权

1.栈

栈是一种只能在一段进行插入和删除的线性数据结构，通常使用线性表来实现。栈满足 **后进先出（LIFO/ last in first out）**的特性

由于栈不能像线性表一样随意进行插入删除，因此可以将栈视为一种功能受限的线性表。

栈的管理结点和线性表的管理结点相同：

顺序表实现栈：数据域(data)、栈的总容量(total)、栈的大小(len)

链表实现栈：栈顶结点(头结点)的指针(*head)、栈的大小(len)

（1）顺序栈的增删改查

【顺序栈也可以使用和顺序表一样的扩容方式】

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

typedef struct Stack{
    int *data;
    int total;
    int len;
} Stack;

Stack *initStack(int total){
    Stack *s = (Stack *) malloc(sizeof(Stack));
    s->data = (int *) malloc(sizeof(int) * total);
    s->len = 0;
    s->total = total;
    return s;
}

void freeStack(Stack *s){
    if(!s) return ;
    free(s->data);
    free(s);
    return ;
}

void push(Stack *s, int val){
    if(!s) return ;
    if(s->len == s->total) return ;
    s->data[s->len] = val; //相当于顺序表的尾插法
    ++ s->len;
    return ;
}

int isEmpty(Stack *s){
    return !s || s->len == 0;
}

int top(Stack *s){
    return s->data[s->len - 1];
}

int pop(Stack *s){
    int val = top(s);
    -- s->len;
    return val;
}

int main(){
    Stack *s = initStack(5);
    for(int i = 0; i < 5; i++){
        push(s, i * 2); // 0 2 4 6 8
    }
    while(!isEmpty(s)){
        printf("%d ", pop(s)); // 8 6 4 2 0
    }
    printf("\n");

    return 0;
}

（2）链栈的增删改查

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

typedef struct Node{
    int val;
    struct Node *next;
} Node;

Node *initNode(int val){
    Node *node = (Node *) malloc (sizeof(Node));
    node->val = val;
    node->next = NULL;
    return node;
}

void freeNode(Node *node){
    if(!node) return ;
    free(node);
}

typedef struct Stack{
    struct Node *head;
    int len;
} Stack;

Stack *initStack(){
    Stack *s = (Stack *) malloc (sizeof(Stack));
    s->head = NULL;
    s->len = 0;
    return s;
}

void freeStack(Stack *s){
    if(!s) return ;
    Node *p = s->head;
    while(p){
        Node *q = p;
        p = p->next;
        freeNode(q);
    }
    free(s);
}

void push(Stack *s, int val){
    if(!s) return ;
    Node *node = initNode(val);
    node->next = s->head;
    s->head = node;
    ++ s->len;
}

int top(Stack *s){
    return s->head->val;
}

int pop(Stack *s){
    int val = top(s);
    Node *node = s->head;
    s->head = s->head->next;
    freeNode(node);
    -- s->len;
    return val;
}

int isEmpty(Stack *s){
    return !s || !s->head;
}

int main(){
    Stack *s = initStack();
    for(int i = 0; i < 10; i++) push(s, i);
    while(!isEmpty(s)) printf("%d ", pop(s));
    printf("\n");
    

    return 0;
}

2.队列

只能在一段进行插入，另一端进行删除的先行数据结构，通常用线性表来实现。

队列满足 **先进先出(FIFO / first in first out)**的特性。与栈类似，队列也可以被看作是一种功能受限的线性表。

队列的管理结点：

顺序表实现的队列：数据域(data)、队首下标(head)、队尾下标(tail)、队列的总容量(total)

链表实现的队列：队首结点的指针(*head)、队尾结点的指针(*tail)、队列的长度(len)

一般来说队列只能查看队首元素，队尾入队首出

(1) 顺序队列

①普通顺序队列的代码演示

每次出栈头指针都会往后移一位，会造成栈顶空间浪费的情况

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

typedef struct Queue{
    int *data;
    int head, tail, total;
} Queue;

Queue *initQueue(int total){
    Queue *q = (Queue *) malloc (sizeof(Queue));
    q->data = (int *) malloc(sizeof(int) * total);
    q->head = 0;
    q->tail = 0;
    q->total = total;
    return q;
}


void freeQueue(Queue *q){
    if(!q) return ;
    free(q->data);
    free(q);
    return ;
}

void push(Queue *q, int val){
    if(!q) return ;
    if(q->tail == q->total) return ;
    q->data[q->tail] = val;
    ++ q->tail;
}

int front(Queue *q){
    return q->data[q->head];
}

int pop(Queue *q){
    int val = front(q);
    ++ q->head;
    return val;
}

int isEmpty(Queue *q){
    return !q || q->head == q->tail;
}

int main(){
    Queue *q = initQueue(10);

    for(int i = 0; i < 9; i++){
        push(q, i);
    }
    while(!isEmpty(q)){
        printf("%d ", pop(q));
    }
    printf("\n");


    return 0;
}
②空间的循环利用

当head或tail大于队列总长size时，head或tail会变为0，即 (head + 1) % total 或者 (tail + 1) % total

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

typedef struct Queue{
    int *data;
    int head, tail, total;
} Queue;

Queue *initQueue(int total){
    Queue *q = (Queue *) malloc (sizeof(Queue));
    q->data = (int *) malloc(sizeof(int) * total);
    q->head = 0;
    q->tail = 0;
    q->total = total;
    return q;
}


void freeQueue(Queue *q){
    if(!q) return ;
    free(q->data);
    free(q);
    return ;
}
//循环队列，保证在n个容量大小的情况下能存放n-1个元素

void push(Queue *q, int val){
    if(!q) return ;
    if(q->head == (q->tail + 1) % q->total) return ;
    q->data[q->tail] = val;
    q->tail = (q->tail + 1) % q->total;
}

int front(Queue *q){
    return q->data[q->head];
}

int pop(Queue *q){
    int val = front(q);
    q->head = (q->head + 1) % q->total;
    return val;
}

int isEmpty(Queue *q){
    return !q || q->head == q->tail;
}

int main(){
    Queue *q = initQueue(10);

    for(int i = 0; i < 4; i++){
        push(q, i);
    }
    while(!isEmpty(q)){
        printf("%d ", pop(q));
    }
    printf("\n");


    for(int i = 10; i < 19; i++){
        push(q, i);
    }
    while(!isEmpty(q)){
        printf("%d ", pop(q));
    }
    printf("\n");

    return 0;
}
③顺序循环队列扩容
int expand(Queue *q){
    int exTotal = q->total;
    int *temp;
    while(exTotal){
        //realloc重新分配空间成功后，指针q->data会被回收，不可以再使用
        temp = (int *) realloc (q->data, sizeof(int) * (q->total + exTotal));
        if(temp) break;
        exTotal >>= 1;
    }
    if(!temp) return 0;
    int i = q->head, j = q->head; //j是原来q->data的head，i是新的temp的q->data的head
    while(j != q->tail){
        temp[i] = temp[j]; //不能使用temp[i] = q->data[j]
        i = (i + 1) % (q->total + exTotal);
        j = (j + 1) % q->total;
    }
    q->tail = i;
    q->data = temp;
    q->total += exTotal;
    return 1;
}

//循环队列，保证在n个容量大小的情况下能存放n-1个元素
void push(Queue *q, int val){
    if(!q) return ;
    if(q->head == (q->tail + 1) % q->total) {
        if(!expand(q)) return ;
    }
    q->data[q->tail] = val;
    q->tail = (q->tail + 1) % q->total;
}

(2) 链队列

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

typedef struct Node{
    int val;
    struct Node *next;
} Node;

Node *initNode(int val){
    Node *node = (Node *) malloc (sizeof(Node));
    node->val = val;
    node->next = NULL;
    return node;
}

void freeNode(Node *node){
    if(!node) return ;
    free(node);
}

typedef struct Queue{
    struct Node *head, *tail;
    int len;
} Queue;

Queue *initQueue(){
    Queue *q = (Queue *) malloc (sizeof(Queue));
    q->head = NULL;
    q->tail = NULL;
    q->len = 0;
    return q;
}

void freeQueue(Queue *q){
    if(!q) return ;
    Node *p = q->head;
    while(p){
        Node *temp = p;
        p = p->next;
        free(temp);
    }
    free(q);
}

//队尾插入
void push(Queue *q, int val){
    if(!q) return ;
    Node *node = initNode(val);
    if(q->len == 0){ //对于链表的第一次插入也可以改成NIL(虚头结点)
        q->head = node;
        q->tail = node;
    } else {
        q->tail->next = node;
        q->tail = q->tail->next;
    }
    ++ q->len;
}

int front(Queue *q){
    return q->head->val;
}

//队首弹出
int pop(Queue *q){
    int val = front(q);
    Node *node = q->head;
    if(q->len == 1){
        q->head = NULL;
        q->tail = NULL;
    } else {
        q->head = q->head->next;
    }
    freeNode(node);
    -- q->len;

    return val;
}

int isEmpty(Queue *q){
    return !q || (!q->head && !q->tail);
}

int main(){
    Queue *q = initQueue();
    for(int i = 0; i < 10; i++) push(q, i);
    while(!isEmpty(q)) printf("%d ", pop(q));
    printf("\n");

    return 0;
}

(3) 双向队列

双向队列可以使用 双向链表 实现，与单链表的区别仅有每个结点存放的指针有两个，分别为前驱结点的指针prev和后继结点的指针next

双向队列同时拥有：头插、尾插、头删、尾删四种增删操作

双向队列既可以当作栈使用又可以当作队列使用

要是对您有帮助，点个赞再走吧~ 欢迎评论区讨论~

Guqing_f
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
栈与队列ppt及代码
09-12
代码涵盖了栈与队列的基本操作以及一些google面试题的实现. 还有详细的PPT讲解
【数据结构】栈和队列：栈的功能实现代码（c语言实现，结尾附代码）
weixin_49088965的博客
03-31 102
本文适合数据结构初学者及实验课代码作为参考
数据结构——栈队列基础操作的代码实现
qq_35890909的博客
03-03 487
队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。空队列：不包含任何元素的空表。队列的常见基本操作//初始化//队列的销毁// 入队列// 出队列最先进入队列的值最后进入对列的值判空取大小2.2 .代码实现。
回文-栈和队列
01-29
栈和队列的基本操作及其应用 1、掌握栈和队列的顺序存储结构和链式存储结构，以便在实际中灵活应用。 2、掌握栈和队列的特点，即后进先出和先进先出的原则。 3、掌握栈和队列的基本运算，如：入栈与出栈，入队与出队等运算在顺序存储结构和链式存储结构上的实现。 回文判断
数据结构实验栈和队列详细实验报告
04-15
实验三 栈和队列 3.1实验目的： （1） 熟悉栈的特点（先进后出）及栈的基本操作，如入栈、出栈等，掌握栈的基本操作在栈的顺序存储结构和链式存储结构上的实现； （2） 熟悉队列的特点（先进先出）及队列的基本操作，如入队、出队等，掌握队列的基本操作在队列的顺序存储结构和链式存储结构上的实现。 3.2 实验要求： （1） 复习课本中有关栈和队列的知识； （2） 用C语言完成算法和程序设计并上机调试通过； （3） 撰写实验报告，给出算法思路或流程图和具体实现（源程序）、算法分析结果（包括时间复杂度、空间复杂度以及算法优化设想）、输入数据及程序运行结果（必要时给出多种可能的输入数据和运行结果）。
数据结构C++ 顺序栈、链栈、循环队列、链队列的主要操作（Word文档含代码和注释）
11-04
注：分为四个内容：顺序栈、链栈、循环队列、链队列。代码由C++程序设计语言编写，包含栈和队列的基本操作（栈：出、入、取、判空等|队列：出、入、取、打印队列、判空等），并展示了三个具体的使用例子，包括用栈求进制转换和用队列打印杨辉三角形，以及用栈计算后缀表达式。代码均已通过VS（附有运行结果截图）。为了防止误修改，文档已限制编辑，密码是：1234。本资源适合数据结构初学者和期末复习等，代码仅供参考。
栈和队列（必会基础代码，万字解析）
weixin_69884785的博客
08-20 441
栈和队列（基础必会代码，万字解析）
栈和队列相关操作及代码
TinyHorse的博客
09-21 892
栈和队列
数据结构栈和队列完整代码复习
狂小伍的博客
11-29 206
栈和队列的完整代码实现
栈和队列代码示例
m0_74981381的博客
11-10 36
原因：非循环顺序队列会出现“rear指向最后一个队列尾部位置，front指示队列倒数第二位置”，该情形下无法再继续插入新的队尾元素因为会出现溢出现象（假溢出），循环队列可以避免这个问题，但需要提前知道队列规模。在入队前不需要判断队列是否已满，只需要为入队元素动态分配结点空间并在出队后释放出队元素所占空间；不需要提前知道队列规模。异：链栈，不需要附设top指针；入栈前不需要像顺序栈那样判断栈是否满而只需要为入栈元素动态分配一个结点空间；类似顺序栈和链栈，顺序队列利用顺序存储结构，链队列利用链式存储结构。
C语言 表、栈和队列详解及实例代码
01-20
C语言 表、栈和队列详解 表ADT  形如A1,A2,A3…An的表，这个表的大小为n，而大小为0的表称为空表，非空表中，Ai+1后继Ai，Ai-1前驱Ai，表ADT的相关操有PrintList打印表中的元素；CreateEmpty创建一个空表；Find...
数据结构栈和队列（参考代码）
06-18
数据结构栈和队列的课程指导上几实验代码 相抵部分
数据结构栈和队列详解.zip
04-03
栈和队列是两种非常基础且重要的数据结构，它们在计算机科学和软件开发中都有着广泛的应用。下面我将详细解释这两种数据结构。 栈（Stack） 栈是一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。这...
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
Leetcode 41. 缺失的第一个正数和Leetcode 155. 最小栈
2301_79614379的博客
04-20 1071
定义一个结构体，数组 data 用于存放推进的数据，数组 min 用于存放最小值，变量 top 存放最后进入的数在 data 的下标，变量 mintop 记录最小值在 min 中的下标。循环遍历数组 nums ，如果该位置的值大于 0 并且不小于数组长度，让哈希表 table 在该值的位置自加。获取堆栈中的最小元素时，根据 mintop 的值返回数组 miin 中的元素。返回栈顶元素时，根据 top 的值返回数组 data 中的元素。--> 返回 -3.输入：nums = [3,4,-1,1]
力扣---从中序与后序遍历序列构造二叉树
m0_71536793的博客
04-20 456
力扣 中序遍历 后序遍历 建树
算法刷题-16
qq_45773834的博客
04-21 667
学习来源： leetcode，牛客 https://programmercarl.com https://www.yuque.com/taxing-qarr6/hxitgt/dedugmp09knerdi1
力扣HOT100 - 543. 二叉树的直径
最新发布
qq_61504864的博客
04-23 158
【代码】力扣HOT100 - 543. 二叉树的直径。
加入栈和队列改进上述代码
04-27
好的，我可以帮你改进上述代码并加入栈和队列的实现。下面是改进后的代码： ``` from collections import deque class ChitGPT: def __init__(self): self.history = deque(maxlen=3) # 使用deque实现队列，最多...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值