栈和队列详解

于 2024-05-31 18:36:17 发布
阅读量1.3k 收藏 23
点赞数 44
文章标签： 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CBNBC/article/details/139359452
版权

  • 栈的表示和实现

  • 栈的概念及结构（栈就相当于一个盒子，只能从一头一个一个放进去，一个一个拿出来）

    练习题：
    1. 答案：B、C
    3. 出栈：栈的删除操作叫做出栈。出数据也在栈顶。
    4. 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
    5. 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out） 的原则。
    6. 实现：
      1. 数组实现（选择这个来实现）
          1. 这样实现的是一个静态的顺序表，缺陷是MAX一旦满了就不能再插入了，所以不建议写静态的
          2. 这样写：
      2. 链表实现
      4. 注意，栈顶是指向数组数据的后面一个
      5. 实现源码：
  • 队列的表示和实现
    1. 表示：队列就相当于一个管道，这边进去，那边出来
      2. 出栈，入两个，出两个这种，是不会改变出队顺序的
    2. 实现：还是两种方式，数组和链表。
      1. 数组：入数据好入，出数据不好出，而且增容不好增容，不太合适
      2. 链表：单链表实现即可
        • 实现代码：
             

    1. 现实世界中的队列的应用：排队
      2. 更深层次的东西：比如如果两个窗口同时空了，同时按到了按钮，同时叫到了102号，这种怎么解决呢？这就涉及到并行操作了，需要后续操作系统的知识，也就是需要加锁来解决问题，先来的人先取，他取了再下一个，这就不至于导致两个窗口抢到一个
  • 栈和队列OJ题
    1. . - 力扣（LeetCode）
      2. 思路：左括号就入栈，如果是右括号，就拿出栈顶的左括号判断二者是否匹配
      3. 实现代码：
// 支持动态增长的栈

typedef char STDataType;

typedef struct Stack

{

    STDataType* _a;

    int _top;       // 栈顶

    int _capacity;  // 容量

}Stack;

// 初始化栈

void StackInit(Stack* ps);

// 入栈

void StackPush(Stack* ps, STDataType data);

// 出栈

void StackPop(Stack* ps);

// 获取栈顶元素

STDataType StackTop(Stack* ps);

// 获取栈中有效元素个数

int StackSize(Stack* ps);

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0

bool StackEmpty(Stack* ps);

// 销毁栈

void StackDestroy(Stack* ps);


// 初始化栈

void StackInit(Stack* ps)

{

    assert(ps);

    ps->_a = NULL;

    ps->_top = ps->_capacity = 0;

}

// 入栈

void StackPush(Stack* ps, STDataType data)

{

    assert(ps);

    //空间不够先增容

    if (ps->_top == ps->_capacity)

    {

        int newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;

        STDataType* tmp = (STDataType*)realloc(ps->_a, sizeof(STDataType) * newcapacity);

        if (tmp == NULL)

        {

            perror("realloc fail\n");

            exit(-1);

        }

        ps->_a = tmp;

        ps->_capacity = newcapacity;

    }

    ps->_a[ps->_top] = data;

    ++ps->_top;

}

// 出栈

void StackPop(Stack* ps)

{

    assert(ps);

    assert(ps->_top > 0);


    --ps->_top;

}

// 获取栈顶元素

STDataType StackTop(Stack* ps)

{

    assert(ps);

    assert(ps->_top > 0);


    return ps->_a[ps->_top - 1];

}

// 获取栈中有效元素个数

int StackSize(Stack* ps)

{

    assert(ps);

    return ps->_top;

}


// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0

bool StackEmpty(Stack* ps)

{

    assert(ps);

    return ps->_top == 0;

}

// 销毁栈

void StackDestroy(Stack* ps)

{

    assert(ps);

    free(ps->_a);


    ps->_a = NULL;

    ps->_top = ps->_capacity = 0;

}


bool isValid(char* s) {

    Stack st;

    StackInit(&st);

    for(int i = 0;s[i] != '\0';++i)

    {

        if(s[i] == '(' || s[i] == '{' || s[i] == '[')

        {

            StackPush(&st,s[i]);

        }

        if(s[i] == ')' || s[i] == '}' || s[i] == ']')

        {

            if(StackEmpty(&st))

            {

                StackDestroy(&st);

                return false;

            }

            char tmp = StackTop(&st);

            if((tmp == '(' && s[i] == ')') || (tmp == '{' && s[i] == '}') || (tmp == '[' && s[i] == ']'))

            {

                StackPop(&st);

            }

            else

            {

                StackDestroy(&st);

                return false;

            }

        }

    }

    bool ret = StackEmpty(&st);

    StackDestroy(&st);

    return ret;

}
      1. OJ报错如何解决？
        • 看报错的测试用例，分析代码，用大脑跟着走读代码
    2. 用队列实现栈
      1. OJ链接：
      2. 思路：
        • 我们可以把另外一个队列当作中间人：
        • 入队列和出队列
          1. 入队列：哪个队列为空，就入到哪个队列里面
          2. 出队列：哪个队列不为空，就先把队尾前的数据倒到另一个队列里面，再pop
      3. 代码
typedef int QDataType;


typedef struct QueueNode

{

    struct QueueNode* next;

    QDataType val;

}QNode;


typedef struct Queue

{

    QNode* phead;

    QNode* ptail;

    int size;

}Queue;


//队列初始化

void QueueInit(Queue* pq);


//队尾进数据

void QueuePush(Queue* pq, QDataType x);


//队头出数据

void QueuePop(Queue* pq);


//队列长度

int QueueSize(Queue* pq);


//获取队头数据：

QDataType QueueFront(Queue* pq);


//获取队尾数据:

QDataType QueueBack(Queue* pq);


//判断空

bool QueueEmpty(Queue* pq);


//队列初始化

void QueueInit(Queue* pq)

{

    pq->phead = NULL;

    pq->ptail = NULL;

    pq->size = 0;

}


//队尾进数据(尾插)

void QueuePush(Queue* pq, QDataType x)

{

    assert(pq);

    QNode* newnode = (QNode*)malloc(sizeof(QNode));

    if (newnode == NULL)

    {

        perror("malloc fail\n");

        exit(-1);

    }

    newnode->next = NULL;

    newnode->val = x;

    if (pq->phead == NULL)

    {

        pq->phead = newnode;

        pq->ptail = newnode;

    }

    else

    {

        pq->ptail->next = newnode;

        pq->ptail = newnode;

    }

    pq->size++;

}


//队头出数据

void QueuePop(Queue* pq)

{

    assert(pq);

    if (pq->size == 1)//一个节点

    {

        free(pq->phead);

        pq->phead = pq->ptail = NULL;

    }

    else//多个节点

    {

        QNode* next = pq->phead->next;

        free(pq->phead);

        pq->phead = next;

    }

    pq->size--;

}


//队列长度

int QueueSize(Queue* pq)

{

    return pq->size;

}


//获取队头数据：

QDataType QueueFront(Queue* pq)

{

    assert(pq);

    return pq->phead->val;

}


//获取队尾数据:

QDataType QueueBack(Queue* pq)

{

    assert(pq);

    return pq->ptail->val;

}


//判断空

bool QueueEmpty(Queue* pq)

{

    return pq->phead == NULL ? true : false;

}


void QueueDestory(Queue* pq)

{

    assert(pq);

    QNode* cur = pq->phead;

    while (cur)

    {

        QNode* next = cur->next;

        free(cur);

        cur = next;

    }

    pq->phead = pq->ptail = NULL;

    pq->size = 0;

}


typedef struct {

    Queue q1;

    Queue q2;

} MyStack;


MyStack* myStackCreate() {

    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));

    QueueInit(&obj->q1);

    QueueInit(&obj->q2);

    return obj;

}


void myStackPush(MyStack* obj, int x) {

    assert(obj);

    if(QueueEmpty(&obj->q1))

    {

        QueuePush(&obj->q2,x);

    }

    else

    {

        QueuePush(&obj->q1,x);

    }

}


int myStackPop(MyStack* obj) {

    assert(obj);

    Queue* empty = &obj->q1;//假设法，假设q1为空

    Queue* noempty = &obj->q2;

    if(!QueueEmpty(&obj->q1))

    {

        empty = &obj->q2;

        noempty = &obj->q1;

    }

    while(QueueSize(noempty) > 1)

    {

        QueuePush(empty,QueueFront(noempty));

        QueuePop(noempty);

    }

    int ret = QueueFront(noempty);

    QueuePop(noempty);

    return ret;

}


int myStackTop(MyStack* obj) {

    assert(obj);

    if(!QueueEmpty(&obj->q1))

    {

        return QueueBack(&obj->q1);

    }

    else

    {

        return QueueBack(&obj->q2);

    }

}


bool myStackEmpty(MyStack* obj) {

    assert(obj);

    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);

}


void myStackFree(MyStack* obj) {

    assert(obj);

    QueueDestory(&obj->q1);

    QueueDestory(&obj->q2);

    free(obj);

}
    1. 用栈实现队列
      1. OJ链接：
      2. 思路与分析
        • 然后你会发现，在s2这个栈里面的数据，已经符合队列的出栈顺序了，所以，我们出数据，就可以直接让s2这个栈pop，
        • 如果需要入数据，我们就push到s1这个栈里面，当s2中的数据pop完了，我们又从s1中把数据倒到s2中去
        • 由此，我们可以设计一个pushst的栈，专门用来入数据，另一个popst的栈，专门用来出数据
      3. 代码：
typedef int STDataType;


typedef struct Stack

{

    STDataType* a;

    int top;//栈顶

    int capacity;//容量

}ST;


//初始化：

void StackInit(ST* ps);


void StackDestory(ST* ps);


void StackPush(ST* ps, STDataType x);


void StackPop(ST* ps);


bool StackEmpty(ST* ps);


STDataType StackTop(ST* ps);


int StackSize(ST* ps);


//初始化：

void StackInit(ST* ps)

{

    assert(ps);

    ps->a = NULL;

    ps->capacity = ps->top = 0;

}


void StackDestory(ST* ps)

{

    assert(ps);

    free(ps->a);

    ps->a = NULL;

    ps->top = ps->capacity = 0;

}


void StackPush(ST* ps, STDataType x)

{

    assert(ps);

    //空间不够先扩容：

    if (ps->top == ps->capacity)

    {

        int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;

        STDataType* tmp = (STDataType*)realloc(ps->a,sizeof(STDataType) * newcapacity);

        if (tmp == NULL)

        {

            perror("malloc failed.\n");

            return;

        }

        ps->a = tmp;

        ps->capacity = newcapacity;

    }

    ps->a[ps->top] = x;

    ps->top++;

}


void StackPop(ST* ps)

{

    assert(ps);

    assert(ps->top > 0);

    ps->top--;

}


bool StackEmpty(ST* ps)

{

    assert(ps);

    return ps->top == 0;

}


STDataType StackTop(ST* ps)

{

    assert(ps);

    assert(ps->top > 0);

    return ps->a[ps->top - 1];

}


int StackSize(ST* ps)

{

    assert(ps);

    return ps->top;

}


typedef struct {

    ST pushST;

    ST popST;

} MyQueue;


MyQueue* myQueueCreate() {

    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));

    StackInit(&obj->pushST);

    StackInit(&obj->popST);

    return obj;

}


void myQueuePush(MyQueue* obj, int x) {

    assert(obj);

    StackPush(&obj->pushST,x);

}


int myQueuePeek(MyQueue* obj) {

    assert(obj);

    if(StackEmpty(&obj->popST))

    {

        //倒数据：

        while(!StackEmpty(&obj->pushST))

        {

            StackPush(&obj->popST,StackTop(&obj->pushST));

            StackPop(&obj->pushST);

        }

        return StackTop(&obj->popST);

    }

    else

    {

        return StackTop(&obj->popST);

    }

}


int myQueuePop(MyQueue* obj) {

    assert(obj);

    int ret = myQueuePeek(obj);//函数复用

    StackPop(&obj->popST);

    return ret;

}


bool myQueueEmpty(MyQueue* obj) {

    return StackEmpty(&obj->pushST) && StackEmpty(&obj->popST);

}


void myQueueFree(MyQueue* obj) {

    assert(obj);

    StackDestory(&obj->pushST);

    StackDestory(&obj->popST);

    free(obj);

}
    1. 设计循环队列
      1. OJ地址：
      4. 什么是循环队列？
      5. 实现思路：设计一个head和tail，让tail永远指向尾数据的下一个
      6. 问题1：怎么解决假溢出问题？
      7. 问题2：回绕问题

通过上面的图，你应该已经发现了tail+1越界了，所以这时候我们需要回绕，有两种解决方案，一种是用条件语句判断，一种是取模操作

让tail + 1 % (k + 1)就可以了，或者：tail == k + 1 ? 0 : tail;

解决完这两个问题，我们就可以上手写代码了：

实现代码：

typedef struct {

    int *a;

    int head;

    int tail;

    int k;

} MyCircularQueue;


bool myCircularQueueIsEmpty(MyCircularQueue* obj) {

    return obj->head == obj->tail;

}


bool myCircularQueueIsFull(MyCircularQueue* obj) {

    return (obj->tail + 1) % (obj->k + 1) == obj->head;//防止tail+1出现溢出问题，我们这里采用模运算进行回绕

}


MyCircularQueue* myCircularQueueCreate(int k) {

    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));


    //多开一个空间解决假溢出问题：

    obj->a = (int*)malloc(sizeof(int) * (k + 1));

    obj->head = obj-> tail = 0;

    obj->k = k;

    return obj;

}


bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {

    if(myCircularQueueIsFull(obj))

        return false;

    obj->a[obj->tail] = value;

    obj->tail++;

    obj->tail %= (obj->k + 1);//解决回绕问题

    return true;//别忘了返回值

}


bool myCircularQueueDeQueue(MyCircularQueue* obj) {//删除就是让head往后走一个，不需要free

    if(myCircularQueueIsEmpty(obj))

        return false;

    obj->head++;

    obj->head %= (obj->k + 1);//head有可能在数组的最后一个，也需要解决回绕问题

    return true;

}


int myCircularQueueFront(MyCircularQueue* obj) {

    if(myCircularQueueIsEmpty(obj))

        return -1;

    return obj->a[obj->head];

}


int myCircularQueueRear(MyCircularQueue* obj) {

    if(myCircularQueueIsEmpty(obj))

        return -1;

    return obj->a[(obj->tail + obj->k) % (obj->k + 1)];//这里应该是obj->tail - 1 + (obj->k + 1),防止出现,tail - 1后出现-1的情况，但是因为我么们加上了k + 1,所以需要一个取模运算给它缩回去，整理一下就可以得到这个式子了；

}


void myCircularQueueFree(MyCircularQueue* obj) {

    free(obj->a);//malloc了两个，从小大大逐层释放

    obj->head = obj->tail = obj->k = 0;

    free(obj);

}

热心市民老八
关注
数据结构（进栈出栈系统编写）
04-17
本文档给出了数据结构中 进栈和出栈的实现
数据结构：栈
qq_55996124的博客
08-03 561
栈(Stack) 1. 概念 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作 进行数据插入和删除操作的一端称为栈顶，另一端称为栈底 栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶 出栈：栈的删除操作叫做出栈。出数据在栈顶 栈的常用方法： 方法 解释 E push(E item) 压栈 E pop() 出栈 E peek() 查看栈顶元素 ..
数据结构：栈(Stack)的各种操作（入栈，出栈，判断栈非空，判断栈已满，附源码）
luming的博客
12-12 8929
栈是一种先进后出（LIFO）的数据结构，在其中元素的的添加（称为“入栈”）和删除（称为“出栈”）仅在栈的顶部进行。因此，最后一个插入到栈中的元素是第一个从栈中删除的元素。 它通常有两个主要操作： 1. push：在栈的顶部插入一个元素。 2. pop：从栈的顶部移除一个元素。 除此之外，也可以进行一些其他的操作，例如查询栈顶元素、获取栈的大小、判断栈是否为空等。栈可以用于很多应用，例如表达式求值、函数调用等。
数据结构-顺序栈（进栈 出栈）
weixin_30662011的博客
06-28 1326
#include<stdio.h> #define MaxSize 10 typedef struct SqStack{ int data[MaxSize]; int top ; }SqStack; //初始化顺序栈 void initStack(SqStack &S){ S.top = -1; } //...
数据结构 —栈的创建、出、进栈
用心做每件事
10-20 270
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define maxsize 20 typedef int ElemType; typedef struct Stack{ ElemType data[maxsize]; int top; }Stack; //初始化 Stack * Init() { Stack *s=(Stack...
C语言 表、栈和队列详解及实例代码
01-20
C语言 表、栈和队列详解 表ADT  形如A1,A2,A3…An的表，这个表的大小为n，而大小为0的表称为空表，非空表中，Ai+1后继Ai，Ai-1前驱Ai，表ADT的相关操有PrintList打印表中的元素；CreateEmpty创建一个空表；Find...
数据结构栈和队列详解.zip
最新发布
04-03
栈和队列是两种非常基础且重要的数据结构，它们在计算机科学和软件开发中都有着广泛的应用。下面我将详细解释这两种数据结构。 栈（Stack） 栈是一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。这...
数据结构栈和队列试题及答案
11-26
### 数据结构之栈和队列知识点详解 #### 一、选择题知识点解析 1. **栈的操作原则** 栈是一种特殊的线性表，它只允许在一端进行插入和删除操作，这一端称为栈顶(top)。另一端称为栈底(bottom)，不允许在其上进行...
数据结构——栈
Dirty_artist的博客
03-30 970
数据结构——栈
【数据结构与算法】栈的介绍及基本运算（出栈、入栈、销毁栈等）
热门推荐
weixin_53161762的博客
03-18 1万+
一、栈的介绍 栈（Stack）是限定只能在表的一端进行插入和删除操作的线性表。 允许插入和删除运算的一端称作栈顶（top）。 不允许插入和删除的另一端称作栈底（bottom）。 在栈顶进行的插入操作称为入栈或进栈(push) 在栈顶进行的删除操作称为出栈或退栈(pop) 栈的特点：后进先出，即 LIFO(Last In First Out) 如下图： 顺序栈的数据类型 静态分配： #define MaxSize 100 #define int ElemType typedef struct { Elem
数据结构角度进行出栈、入栈操作
qq690759219的博客
05-01 415
#include&lt;stdio.h&gt;#include&lt;malloc.h&gt;#include&lt;stdlib.h&gt;typedef struct Node{ int data; struct Node * pNext;}NODE,* PNODE;typedef struct Stack{ PNODE pTop; PNODE pBottom;}STACK,* PSTACK;...
【数据结构入门】栈（Stack）的实现（定义、销毁、入栈、出栈等） | 图解数据结构，超详细哦~
codewinter的博客
09-11 6706
文章目录（1）前言1）栈的概念2）进栈出栈的形式3）栈的存储结构（2）栈的实现（顺序栈）1）栈的定义2）栈的初始化3）栈的销毁4）入栈5）出栈6）检测栈是否为空7）获取栈中有效元素个数8）获取栈顶元素（3）测试栈的功能 数据结构系列文章： 【数据结构入门】顺序表（SeqList）详解（初始化、增、删、查、改） 【数据结构入门】无头单向非循环链表（SList）详解（定义、增、删、查、改） | 图解链表，超生动详细哦~ 【数据结构入门】带头双向循环链表（List）详解（定义、增、删、查、改） | 配有大量图解，
栈代码
ZHYFXY的博客
03-23 2908
顺序栈 #include #include #define MAXSIZE 20 #define OK 1 #define ERROR 0   typedef int data_t; typedef struct { data_t data[MAXSIZE]; int top; }SqStack;   int PushStack(SqStack *s,data_t
【数据结构】——入栈出栈
qq_43502163的博客
11-21 3016
[数据结构之入栈出栈] Hello我是被计算机编程语言支配的可怜兮兮的γ。 o(╥﹏╥)o 数据结构是这学期上，之前的程序我都没有想过要总结，至于这个为什么要po出来，估计也就是因为我写了这么多注释吧（突然感jio自己好伟大，我反正是能看懂的哈哈你们应该也可以） 但是注解里还是有一些可能存在错误，所以我更希望各位大佬能在线指导指导。ball ball你们了…… 这篇数据的主要原理，就是入栈出栈顺序...
数据结构：顺序栈和链式栈
ljj20314的博客
10-20 285
栈：限定在表尾进行插入和删除操作的线性表。 允许插入和删除的一端成为栈顶，另一端称为栈底。 顺序栈： const int MAX_SIZE=100; template class seqStack { public: seqStack ( ) ; ~seqStack ( ); void Push ( T x ); T Pop ( ); T GetTop ( ); bool ...
【数据结构】顺序栈和链栈--Stack
Z1tai的博客
11-11 2082
栈是一种线性数据结构，它的元素按照特定的顺序进行插入和删除操作。栈的插入操作称为入栈（push），删除操作称为出栈（pop）。栈可以看作是一种具有限制访问的线性表，只能在表的一端进行插入和删除操作，称为栈顶（top）, 而另一端则称为栈底（bottom）。栈是计算机科学中非常重要的数据结构，它具有简单且高效的特点。我们深入了解了栈的概念、用途、基本操作和实现细节。通过掌握栈的原理和应用，我们可以更好地理解和使用它，从而在解决实际问题时发挥其优势。
数据结构：顺序栈与链栈
qq_40657299的博客
11-13 648
栈(stack): 概念：栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 栈是允许在同一端进行插入和删除操作的
栈代码(C)
qq_53015985的博客
04-17 179
#include<stdio.h> #include<stdlib.h> typedef struct Node{ int data; struct Node* next; }Node; typedef struct Stack{ int size; Node* stacktop; }Stack; //创建栈 Stack* createstack(){ Stack* mystack=(Stack*)malloc(sizeof(Stack))
栈和队列详解：取链队列首元素
"该资源主要介绍了数据结构中的栈和队列，特别是如何取链队列的第一个元素，并提供了栈的相关概念、实现方式以及操作示例。" 在数据结构中，栈和队列是两种非常基础且重要的线性数据结构。栈（Stack）遵循“后进先...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值