算法---栈和队列

最新推荐文章于 2024-07-17 23:24:38 发布
最新推荐文章于 2024-07-17 23:24:38 发布
阅读量621 收藏
点赞数
分类专栏： 算法 文章标签： 栈 队列 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41683305/article/details/124282323
版权

栈和队列

1 栈

参考文章：
https://zhuanlan.zhihu.com/p/346164833
https://zhuanlan.zhihu.com/p/120965372#:~:text=%E6%A0%88%E6%98%AF%E4%B8%80%E7%A7%8D%20%E5%90%8E%E8%BF%9B%E5%85%88%E5%87%BA%EF%BC%88LIFO%EF%BC%89,%E7%9A%84%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%20%E8%BF%9B%E6%A0%88%E7%9A%84%E9%A1%BA%E5%BA%8F%E4%B8%BAa1%2Ca2%2Ca3%2Ca4%2Ca5%EF%BC%8C%E5%87%BA%E6%A0%88%E7%9A%84%E9%A1%BA%E5%BA%8F%E4%B8%BAa5%2Ca4%2Ca3%2Ca2%2Ca1

栈是一种特殊的线性表，仅允许在一端进行插入和删除。被允许插入和删除的一端为栈顶（top），另一端称为栈底（bottom），栈底是固定的，不允许进行插入和删除
在这里插入图片描述
栈的主要基本操作有：

  1. InitStack(&S)：初始化栈
  2. StackEmpty(S)：判断一个栈是否为空
  3. Push(&S,x)：进栈，若栈未满，则将x加入到栈顶
  4. pop(&S,&x)：出栈，若栈非空，则将栈顶元素出栈，并用x返回

栈的顺序存储

采用顺序存储的栈称为顺序栈，用数组实现。
栈的定义为：

#define STACK_SIZE 100

typedef int ElmType;

typedef struct{
    int top;    /* 栈顶指针 */
    ElmType data[STACK_SIZE];   /* 顺序栈 */
}SqStack;
  • 栈顶指针：S.top，初始时设置S.top = -1；栈顶元素：S.data[top]；
  • 进栈操作：先判断S.top==STACK_SIZE-1，若栈不满，S.top加1，然后将值送到栈顶。
  • 出栈操作：栈非空时，先去栈顶元素值，然后再将栈顶指针减1
  • 栈空条件：S.top==-1
  • 栈满条件：S.top==STACK_SIZE-1
  • 栈长：S.top+1

栈的链式存储

采用链式存储的栈称为链栈，链栈的优点是便于多个栈共享存储空间和提高其效率，且不存在栈满上溢的情况。通常采用单链表实现，并规定所有操作都是在单链表的表头进行的。这里规定链栈没有头结点，top指向栈顶元素，
请添加图片描述
链栈的存储可定义为：

typedef int ElemType;
typedef struct LinkNode{
    ElemType data;
    struct LinkNode *next;
}LinkStack;

2 队列

队列是只允许在一端进程插入操作，在另一端进行删除操作的线性表。被允许插入的一端叫队尾（rear），被允许删除的一端叫队头（front）。

请添加图片描述
队列的主要基本操作有：

  1. InitQueue(&Q)：初始化队列
  2. QueueEmpty(Q)：判断队列是否为空
  3. QueueLenght(Q)：判断队列中元素的个数
  4. push(&Q,x)：入队，如果队列没有满，就在队尾插入x
  5. pop(&Q,&x)：出队，如果队列非空，就在队首删除一个元素，并用x返回

队列的顺序存储

类型定义为：

#define QUEUE_SIZE 100
typedef int ElemType;
typedef struct 
{
    ElemType data[QUEUE_SIZE];  /* 队列 */
    int front;  /* 队首 */
    int rear;   /* 队尾 */
}SqQueue;

由于普通队列存在溢出问题，所以我们用循环队列，循环队列的定义和普通队列定义一样。
请添加图片描述

说明：这里浪费一个存储空间

  • 初始化：rear=front=0
  • 添加一个元素：如果队列没有满，则插入，即Q[rear] = x,rear= （rear+1）%QUEUE_SIZE
  • 删除一个元素：如果队列非空，则删除，即*x=Q[front]，front = （front+1）% QUEUE_SIZE
  • 判断队列是否为空：rear==front
  • 判断队列是否满：(rear+1)%QUEUE_SIZE==front
  • 队列元素个数：(rear-front+QUEUE_SIZE)%QUEUE_SIZE

队列的链式存储

队列的数组实现比较麻烦，需要考虑各种边界情况，所以通常使用链表形式来实现队列。

使用单向链表来实现链式队列，链式队列中存储front和rear即可。

typedef int ElemType;
typedef struct node
{
    int date;
    struct node *next;
}LinkNode;
typedef struct queue{
    LinkNode *front;
    LinkNode *rear;
}LinkQueue;

3 栈和队列的应用

用栈实现队列

参考文章：https://cloud.tencent.com/developer/article/1643318

LeedCode题目位置：232. 用栈实现队列

队列的特性是新加入的元素在队尾，最先入队的元素排在队首，按队首到队尾的顺序依次出栈。用栈实现队列，需要把新加入的元素保留在栈底，保证栈顶是队列最先加入的元素。

所以我们用两个栈A、B来实现，每次入队时，先把存放数据的栈A弹出到另一个栈B，然后把数据存到A，最后把B中的元素依次弹出压入A栈中，这样保证了新加入的元素在栈底。
请添加图片描述
队列出队是把队列队首的删除，对应栈是把栈A的栈顶元素删除。

实现代码如下：

#include <stdlib.h>

typedef char bool;

#define SIZE 100
#define false 0
#define true 1
/* 栈的定义 */
typedef struct{
    int length;
    int data[SIZE];
}Stack;

/* 初始化栈 */
Stack *initStack()
{
    Stack * ret = malloc(sizeof(Stack));
    ret->length=-1;
    return ret;
}

/* 判断栈是否为空 */
bool StackEmpty(Stack *s)
{
    return s->length==-1;
}

/* 入栈操作 */
bool stackPush(Stack *s,int x)
{
    if(s->length==SIZE-1)
    {
        return false;
    }
    s->length++;
    s->data[s->length]=x;
    return true;
}
/* 出栈操作 */
bool stackPop(Stack *s,int *x)
{
    if(s->length==-1)
    {
        return false;
    }
    *x = s->data[s->length];
    s->length--;
    return true;
}

/* 释放栈 */
void freeStack(Stack *s)
{
    free(s);
}

typedef struct {
    Stack *inStack;
    Stack *outStack;
} MyQueue;

/* 创造队列 */
MyQueue* myQueueCreate() {
    MyQueue *ret = (MyQueue *)malloc(sizeof(MyQueue));
    ret->inStack = initStack();
    ret->outStack = initStack();
    return ret;
}

void myQueuePush(MyQueue* obj, int x) {
    int y;
    /* 先把栈A的元素依次弹出放到栈B */
    while(stackPop(obj->inStack,&y))
    {
        stackPush(obj->outStack,y);
    }
    /* 把入队的元素放到栈A的栈底 */
    stackPush(obj->inStack,x);
    /* 依次弹出栈B的元素放到栈A */
    while(stackPop(obj->outStack,&y))
    {
        stackPush(obj->inStack,y);
    }
}

int myQueuePop(MyQueue* obj) {
    int x;
    /* 删除栈A的栈顶元素 */
    stackPop(obj->inStack,&x);
    return x;
}

int myQueuePeek(MyQueue* obj) {
    return obj->inStack->data[obj->inStack->length];
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(obj->inStack);
}

void myQueueFree(MyQueue* obj) {
    free(obj->inStack);
    free(obj->outStack);
    free(obj);
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

在这里插入图片描述

用队列实现栈

参考文章：https://cloud.tencent.com/developer/article/1643318
LeedCode题目位置：225. 用队列实现栈
栈的特性是新加入的元素出现在栈顶，删除的元素也在栈顶，队列的特性是新加入的特性在队尾，删除的元素在队首。
我们可以让数据先入队列，然后把队列的以前的数据依次出队再入队，这样保证了新压入的数据在队首，对应栈的栈顶。
请添加图片描述
出栈的话，对应队列的操作就是把队首的元素删除即可。
实现代码如下：

#include <stdlib.h>

#define false 0
#define true 1
#define SIZE 101



typedef struct{
    int front;  // 队首
    int rear;   //队尾
    int data[SIZE];
}Queue;

/* 初始化队列 */
Queue * initQueue()
{
    Queue * ret = (Queue *)malloc(sizeof(Queue));
    ret->front=0;
    ret->rear=0;
    return ret;
}
/* 判断队列是否为空 */
bool QueueEmpty(Queue *q)
{
    if(q->front==q->rear)
    {
        return true;
    }else
        return false;
}

/* 入队 */
bool queuePush(Queue *q,int x)
{
    /* 队满 */
    if(q->front == (q->rear+1)%SIZE)
    {
        return false;
    }
    q->data[q->rear]=x;
    q->rear =(q->rear+1)%SIZE;
    return true;
}
/* 出队 */
bool QueuePop(Queue *q,int *x)
{
    /* 队列是否为空 */
    if(q->front==q->rear)
        return false;
    *x = q->data[q->front];
    q->front = (q->front+1)%SIZE;
    return true;
}
/* 获取队首元素 */
int getQueueTop(Queue *q)
{
    return q->data[q->front];
}
typedef struct {
    Queue *q;
} MyStack;


MyStack* myStackCreate() {
    MyStack *ret = (MyStack *)malloc(sizeof(MyStack));
    ret->q = initQueue();
    return ret;
}

void myStackPush(MyStack* obj, int x) {
    int y;
    /* 计算现在有多少个元素 */
    int length = (obj->q->rear-obj->q->front+SIZE)%SIZE;
    /* x入队 */
    queuePush(obj->q,x);
    for(int i=0;i<length;i++)
    {
        /* 出队 */
        QueuePop(obj->q,&y);
        /* 入队 */
        queuePush(obj->q,y);
    }
}
/* 只需将队首元素删除 */
int myStackPop(MyStack* obj) {
    int x;
    QueuePop(obj->q,&x);
    return x;
}

int myStackTop(MyStack* obj) {
    return getQueueTop(obj->q);
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(obj->q);
}

void myStackFree(MyStack* obj) {
    free(obj->q);
    free(obj);
}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/

在这里插入图片描述

最小栈

LeedCode位置：155. 最小栈
题目要求在常数时间内检索到最小元素的栈，所以我们在栈里面设置一个变量min来记录最小元素的位置。

当插入元素，如果插入的元素比栈内的元素都要小，这个时候需要更新min；当删除元素时，如果此时最小的元素在栈顶，也需要更新min值。

代码实现如下：

#include <stdlib.h>

#define SIZE 30000

typedef struct {
    int length;    //记录元素个数,始终指向栈顶元素
    int min;    //记录最小元素的位置
    int data[SIZE];
} MinStack;

int getStackMin(MinStack *s)
{
    int min =0;
    for(int i=1;i<=s->length;i++)
    {
        if(s->data[min]>s->data[i])
        {
            min = i;
        }
    }
    return min;
}

MinStack* minStackCreate() {
    MinStack *ret = (MinStack *)malloc(sizeof(MinStack));
    ret->length = -1;
    ret->min = 0;
    return ret;
}

void minStackPush(MinStack* obj, int val) {
    obj->data[++obj->length]=val;
    /* 插入的元素比栈内的元素都要小，这个时候需要更新min */
    if(val<obj->data[obj->min])
        obj->min = obj->length;
}

void minStackPop(MinStack* obj) {
    obj->length--;
    /* 删除元素时，如果此时最小的元素在栈顶，也需要更新min值 */
    if(obj->min==(obj->length+1))
    {
        obj->min = getStackMin(obj);
    }
}

int minStackTop(MinStack* obj) {
    return obj->data[obj->length];
}

int minStackGetMin(MinStack* obj) {
    return obj->data[obj->min];
}

void minStackFree(MinStack* obj) {
    free(obj);
}

/**
 * Your MinStack struct will be instantiated and called as such:
 * MinStack* obj = minStackCreate();
 * minStackPush(obj, val);
 
 * minStackPop(obj);
 
 * int param_3 = minStackTop(obj);
 
 * int param_4 = minStackGetMin(obj);
 
 * minStackFree(obj);
*/

在这里插入图片描述

p0inter
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
亲爱的栈与队列
weixin_42107392的博客
10-16 1114
亲爱的栈与队列前言栈定义基本操作顺序栈共享栈链栈队列定义基本操作队列顺序实现二、使用步骤1.引入库2.读入数据总结 前言 只允许在一端进行插入或删除操作的线性表，联想穿烤串和吃烤串，咳咳，我是说下面这种签子： 栈 定义 烤串的尖头是栈顶，手握的一端是栈底，不管是穿串还是吃串都得从尖的那头操作，先穿进去的肉最后才吃得到，Last In First Out(LIFO)! 基本操作 InitStack(&S):初始化，即拿一根签子 DestroyStack(&L):销毁，即吃完烤串还把签子扔了
算法-栈与队列
weixin_51360664的博客
03-09 149
1.用栈实现队列 使用栈实现队列的下列操作： push(x) -- 将一个元素放入队列的尾部。 pop() -- 从队列首部移除元素。 peek() -- 返回队列首部的元素。 empty() -- 返回队列是否为空。 class Solution: def __init__(self): self.s1 = [] self.s2 = [] def push(self,x): self.s1.append(x) def po
数据结构——（3）、栈和队列
DF10f-0001A
11-14 1330
一、栈 1、定义 栈是只允许在一端进行插入或删除的线性表。首先栈是一种线性表。栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构。因此，对栈来说，表尾端有其特殊含义，称为栈顶（top)，相应地，表头端称为栈底（bottom )。不含元素的空表称为空栈。 2、栈的特征 主要特点是“后进先出”,即后进栈的元素先处理。因此栈又称为后进先出(last infirst out, LIFO)表。 3、栈的常见操作 InitStack(&S)：初始化一个空栈S。.
（C语言）堆栈和队列实验
qq_52491362的博客
10-23 2438
1.（1）：判断一个算术表达式中开括号和闭括号是否配对。 实现代码： #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 typedef struct{ char data[MAXSIZE]; int top; }seqstack; int MatchCheck(char str[]){ seqstack s; int i = 0; s.top = -1; while (str[i] != '\0'){
队列的介绍及面试题（用队列实现栈）
belongHWL的博客
09-16 219
一：队列的概念 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表； 队列具有先进先出 FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头、 二：队列的实现 队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数 组头上出数据，效率会比较低。 ...
大话西游之王道考研数据结构第三讲---栈
PoorLemon的博客
07-28 2047
                                               第三讲---栈 复习 上次我们讲到了线性表的链式表示，这里我们做一个简单的复习： 线性表的链式表示有哪些特点？ 访问方面 存储方面 不同操作的复杂度方面 线性表有几种表示方式？ 链表中你能想到几种结构？（最简单的有单链表，还有什么链表，分别有什么特点） 链表的插入、删除中，不同链表结...
栈和队列---算法题目
flipped___的博客
07-18 427
1.设计一个有getMin功能的栈 1.解题思路 方案一： push：将每次插入的新值和stackMin的栈顶元素比较，如果新值较小就插入到stackMin，否则什么也不干 pop：stackData出栈的元素如果是栈中最小元素，则stackMin对应的元素也要出栈 方案二： push：将方案二“什么也不干”这件事改为重复插入stackMin栈顶元素 pop：因为push操作重复的插入，则pop时不需要比较stackData出栈元素是否是stackMin栈顶元素，两个栈 同步出栈即可。 2.遇
基础算法----线性表和栈，队列
04-03
线性表和栈、队列是计算机科学中最基础的数据结构，它们在算法设计和实现中起着至关重要的作用。线性表是一种简单的数据组织形式，它由若干个相同类型元素构成的有限序列，可以顺序存储或链式存储。栈和队列则是...
Java算法练习-队列和栈
10-01
[Java]算法练习-队列和栈
数据结构与算法-实验3 栈和队列
11-19
本实验主要涉及两种常用的数据结构——栈（Stack）和队列（Queue），并要求通过实验实现这两种数据结构的不同版本：顺序栈、链栈、循环队列和链队列。 **栈**是一种后进先出（LIFO, Last In First Out）的数据结构...
fengbear#CS-Book#算法 - 栈和队列1
07-25
1. 数组实现 2. 链表实现 1. 数组实现 2. 链表实现
LinLiKang#CS-Notes#算法 - 栈和队列1
07-25
1. 数组实现 2. 链表实现 1. 数组实现 2. 链表实现
算法之栈和队列
taka_is_beauty的博客
05-31 404
1.设计一个有getmin功能的栈 思路：创建一个栈叫minstack，维护一个从栈底大栈顶的递减栈。 ps：压栈时原栈正常压入，在minstack栈中如果value大于栈就不压入，如果小于等于就压栈。这样就维护了一个从底到顶的降序序列 ps：出栈时原栈正常出栈，在minstack栈中如果出栈的元素大于栈顶就不出，如果等于栈顶元素就出栈，是不可能小于栈顶元素的因为栈顶就放的是最小元素。 2...
算法刷题5【剑指offer系列之栈和队列】
weixin_39984317的博客
06-21 156
2020.06.21 1、两个栈来实现一个队列 用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。 思路： 1、入栈只入push栈，出栈只出pop栈 2、若pop栈不为空，push栈不能进入 3、push栈的元素如果可以加入到pop栈，则需要全部一起到pop栈 public class Stack2Queue { Stack<Integer> pushStack = new Stack<Integer>(); Stack<Int
2021年实训（队列）
CSDN_LIUCHENGYU的博客
07-06 147
2021年实训（队列） 今天学习了手打队列，为下个学期的数据结构做准备，例题是一个迷宫问题。 程序设计综合实训-迷宫问题（II） 顺序队列 #include <stdio.h> #include <stdlib.h> #define MAX 2505 typedef struct { int x; int y; int len; }pos; typedef struct { int front; int rear; pos queue[
栈相关习题及详解(选择题和综合题) ——数据结构
Amour
10-26 9676
栈的基本概念栈的定义栈：只允许在一端进行插入或删除操作的线性表。首先栈是一种线性表，但是限定这种线性表只能在某一端进行插入和删除操作。栈顶：线性表允许进行插入和删除的那一端 栈底：固定的，不允许进行插入和删除的另一端 空栈：不含任何元素的空表。进栈出栈的变化形式最先进栈的元素，是不是就只能是最后出栈呢答案是不一定，要看什么情况。栈对线性表的插入和删除的位置进行了限制，并没有对元素进出的时间进行限
40. 用栈实现队列
strike1989的博客
03-06 144
正如标题所述，你需要使用两个栈来实现队列的一些操作。队列应支持push(element)，pop() 和 top()，其中pop是弹出队列中的第一个(最前面的)元素。pop和top方法都应该返回第一个元素的值。样例比如push(1), pop(), push(2), push(3), top(), pop()，你应该返回1，2和2public class MyQueue { St...
栈（Stack）顺序栈以及链栈的相关操作（C语言）
派拉斯兔子的博客
05-07 1357
<img src='https://img-blog.csdnimg.cn/2021050719043789.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDk2Njcw,size_16,color_FFFFFF'>
排序算法(4)之快速排序(1)
最新发布
wer24_25的博客
07-17 1131
排序算法(4)之快速排序(1),快速排序的概念和快速排序的三种实现方式.
栈和队列解析：回文检测算法
"该资源主要讨论了如何判断一个字符串是否...掌握栈和队列的特性和实现方式对于理解和解决各种计算机科学问题至关重要，特别是在算法设计和数据结构的学习中。通过深入理解这些基础概念，可以更好地应对复杂编程挑战。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值