AI 助理
备案控制台
开发者社区 云计算 文章 正文

数据结构--栈和队列

2024-03-15 136
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 数据结构--栈和队列


栈的概念和结构

栈是一种常见的数据结构，它遵循后进先出LIFO（Last In First Out）的原则。进行数据插入和操作的一端称为栈顶，另一端称为栈底。

压栈：栈的插入操作被称为压栈/进栈/入栈，入数据在栈顶。

出栈：栈的删除操作。出数据也在栈顶；

栈的实现

栈可以用数组或者是链表来实现；这里将使用数组来实现，因为数组在插入删除时消耗代价较小；对于链表，由于Top放在尾，删除时还需要由头指针循环遍历找到尾结点前一个；

栈的数据结构

typedef int STDataType;
typedef struct Stack
{
  STDataType* a;
  int top;
  int capacity;
}ST;

a为存储数据的数组，top表示栈顶，capacity表示当前数组的存储容量；

栈的初始化和销毁

void STInit(ST* ps)
{
  assert(ps);
  ps->a = NULL;
  ps->top = 0;
  ps->capacity = 0;
}
void STDestory(ST* ps)
{
  assert(ps);
  free(ps->a);
  ps->a = NULL;
  ps->capacity = 0;
  ps->top = 0;
}

assert（ps）验证的是传过来的地址，地址为NULL那就无法进行操作；

free完ps->a记得置空；

出栈和入栈

void STPush(ST* ps, STDataType x)
{
  assert(ps);
  //满扩容
  if (ps->top == ps->capacity)
  {
    int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
    STDataType* tmp = realloc(ps->a, sizeof(STDataType) * newcapacity);
    if (tmp == NULL)
    {
      perror("Stack fail");
      exit(-1);
    }
    ps->a =tmp;
    ps->capacity = newcapacity;
  }
  ps->a[ps->top] = x;
  ps->top++;
}
void STPop(ST* ps)
{
  assert(ps);
  assert(ps->top > 0);
  ps->top--;
}

这里的Top是放在最后一位元素之后的；

当出栈时，不用管那个位置的内容和空间是否被删除，当下次入栈到这个位置，内容会被顶替；而如果用free掉这一块空间，会造成只释放部分空间的错误；

获取栈顶、大小，判空

STDataType STTop(ST* ps)
{
  assert(ps);
  assert(ps->top > 0);
  return ps->a[ps->top - 1];
}
int STSize(ST* ps)
{
  assert(ps);
  return ps->top;
}
bool STEmpty(ST* ps)
{
  assert(ps);
  return ps->top==0;
}

对于数据结构来说，即使是简单的操作也要用函数进行封装；这样做的原因能够找出一些错误的操作，能够方便别人的操作；

例如你在主函数创建的栈为空，然后给到别人使用，别人不知道栈为空，别人没有用函数判断栈的大小，出来的栈的大小无法辨别是对的还是错误的；而创建函数就能够避免一些极端问题；

接下来我们简单的验证一下：

void Test1()
{
  ST st;
  STInit(&st);
  STPush(&st, 1);
  STPush(&st, 2);
  STPush(&st, 3);
  STPush(&st, 4);
  
  while (!STEmpty(&st))
  {
    printf("%d ", STTop(&st));
    STPop(&st);
  }
  printf("\n");
  STDestory(&st);
}
int main()
{
  Test1();
  return 0;
}

队列的概念和结构

队列只允许在一端进行插入操作，在另一端删除数据操作的特殊线性表，具有先进先出FIFO(First In First Out) ；

入队列：在队尾进行插入的操作

出队列：在队头进行删除的操作

队列的实现

队列的实现可以用数组和链表来实现；这里将使用链表来实现；因为如果使用数组的结构，在数组头进行删除出数据，效率比较低；

队列的数据结构

typedef int QDataType;
typedef struct QueneNode
{
  struct QueneNode* next;
  QDataType data;
}QNode;
typedef struct Quene
{
  QNode* head;
  QNode* tail;
  int size;
}Quene;

这里先用一个结构体将一个结点的类型进行封装；然后再用一个结构体进行队列的封装；因为这里我们将会使用队头和队尾，如果使用这两个进行传参，将会用到二级指针，比较麻烦，所以就使用一个结构体进行封装，用结构体进行传参，用到队头和队尾只需调用结构体的成员；

队列的初始化和销毁

void QueneInit(Quene* pq)
{
  assert(pq);
  pq->head = pq->tail = NULL;
  pq->size = 0;
}
void QueneDestory(Quene* pq)
{
  assert(pq);
  QNode* cur = pq ->head;
  while (cur)
  {
    QNode* next = cur->next;
    free(cur);
    cur = next;
  }
  pq->head = pq->tail = NULL;
  pq->size = 0;
}

初始化将head和tail都置空；size统计多少个结点；

销毁用循环遍历逐渐将结点释放；最后将指针置空；

队列的插入

void QuenePush(Quene* pq, QDataType x)
{
  assert(pq);
  //扩容
  QNode* newnode = (QNode*)malloc(sizeof(QNode));
  if (newnode == NULL)
  {
    perror("malloc fail");
    exit(-1);
  }
  newnode->data = x;
  newnode->next = NULL;
  //第一个插入
  if (pq->head == NULL)
  {
    pq->head = pq->tail = newnode;
  }
  else
  {
    pq->tail->next = newnode;
    pq->tail = newnode;
  }
  pq->size++;
}

首先是每插入一次就扩容一个结点；接着是判断是否为第一个结点的插入，如果是需要将head和tail都等于新节点；最后将size加加；

队列的删除

void QuenePop(Quene* pq)
{
  assert(pq);
  //判断是否没有数据
  assert(!QueneEmpty(pq));
  QNode* next = pq->head->next;
  //只有一个数据
  if (pq->head->next == NULL)
  {
    free(pq->head);
    pq->head = pq->tail = next;
  }
  else
  {
    free(pq->head);
    pq->head = next;
  }
  pq->size--;
}

我们需要判断有没有结点可以删除；然后记住头结点的下一个结点，删除头结点后将头结点指针等于下一个结点；如果只有一个结点可以删除，那么还要将tail置空；

获取队头和队尾的数据

QDataType QueneFront(Quene* pq)
{
  assert(pq);
  assert(!QueneEmpty(pq));
  return pq->head->data;
}
QDataType QueneBack(Quene* pq)
{
  assert(pq);
  assert(!QueneEmpty(pq));
  return pq->tail->data;
}

获取队列长度和判空

int QueneSize(Quene* pq)
{
  assert(pq);
  return pq->size;
}
bool QueneEmpty(Quene* pq)
{
  assert(pq);
  return pq->head == NULL;
}

最后做一下简单的验证

void Test1()
{
  Quene q;
  QueneInit(&q);
  QuenePush(&q, 1);
  QuenePush(&q, 2);
  QuenePush(&q, 3);
  QuenePop(&q);
  while (QueneSize(&q)>0)
  {
    printf("%d ", QueneBack(&q));
    QuenePop(&q);
  }
  QueneDestory(&q);
}
int main()
{
  Test1();
  return 0;
}

栈和队列的一些题目

1.有效的括号

思路：这道题可以采用栈这种结构来解决问题，满足后进先出的原理；

我们可以这么做，分为左括号和右括号；遇到左括号就放入栈中，一旦遇到右括号，我们可以将栈顶取出，进行判断；这是我们的大体思路；

这道题我们还需要考虑一些极端情况：

第一种：字符串中只有右括号或者说一开始就是右括号，那么这种就相当于栈为空；当遇到右括号时，需要先进行判断；

第二种：字符串只有左括号，那么表明栈中的元素没有进行匹配出栈，栈不为空；

所以把特殊情况弄好后，就可以进行操作了，我们可以把我们写的栈结构复制到程序中，然后创建一个栈来进行操作；最后记得释放空间，避免内存泄漏；

代码：

#define  _CRT_SECURE_NO_WARNINGS 1
typedef char STDataType;
typedef struct Stack
{
  STDataType* a;
  int top;
  int capacity;
}ST;
void STInit(ST* ps)
{
  assert(ps);
  ps->a = NULL;
  ps->top = 0;
  ps->capacity = 0;
}
void STDestory(ST* ps)
{
  assert(ps);
  free(ps->a);
  ps->a = NULL;
  ps->capacity = 0;
  ps->top = 0;
}
void STPush(ST* ps, STDataType x)
{
  assert(ps);
  if (ps->top == ps->capacity)
  {
    int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
    STDataType* tmp = realloc(ps->a, sizeof(STDataType) * newcapacity);
    if (tmp == NULL)
    {
      perror("Stack fail");
      exit(-1);
    }
    ps->a =tmp;
    ps->capacity = newcapacity;
  }
  ps->a[ps->top] = x;
  ps->top++;
}
void STPop(ST* ps)
{
  assert(ps);
  assert(ps->top > 0);
  ps->top--;
}
STDataType STTop(ST* ps)
{
  assert(ps);
  assert(ps->top > 0);
  return ps->a[ps->top - 1];
}
int STSize(ST* ps)
{
  assert(ps);
  return ps->top;
}
bool STEmpty(ST* ps)
{
  assert(ps);
  return ps->top==0;
}
bool isValid(char * s){
    ST st;
    //栈初始化
    STInit(&st);
    while(*s)
    {
        //左括号就入栈
        if(*s=='('||*s=='['||*s=='{')
        {
            STPush(&st,*s);
        }
        //右括号就出栈，判断
        else
        {
            栈空，表明没有左括号
            if(STEmpty(&st))
            {
                STDestory(&st);
                    return false;
            }
            char val=STTop(&st);
            STPop(&st);
            //不符合
            if((*s==')'&&val!='(')
            ||(*s==']'&&val!='[')
            ||(*s=='}'&&val!='{'))
            {
                return false;
            }
               
        }
        s++;
    }
    if(!STEmpty(&st))
    {
        return false;
    }
    STDestory(&st);
    return true;
}

2.用队列实现栈

思路：我们可以在纸上模拟一下入栈和出栈的操作；

由于入栈的时候和队列的性质一样，都在尾插入，所以不需要执行什么操作；出栈时，总需要进行转移，才能删除最后一个元素；那么可以先判断那个队列空与不为空，然后将不为空的进行转移到空的队列；那么就可以完成出栈；同时，由于这样的操作，入栈时如果有一个队列不为空需要将元素插入不为空的后面，方便出栈的操作；

代码：

#include<assert.h>
#include<stdbool.h>
typedef int QDataType;
typedef struct QueneNode
{
  struct QueneNode* next;
  QDataType data;
}QNode;
typedef struct Quene
{
  QNode* head;
  QNode* tail;
  int size;
}Quene;
void QueneInit(Quene* pq)
{
  assert(pq);
  pq->head = pq->tail = NULL;
  pq->size = 0;
}
void QueneDestory(Quene* pq)
{
  assert(pq);
  QNode* cur = pq ->head;
  while (cur)
  {
    QNode* next = cur->next;
    free(cur);
    cur = next;
  }
  pq->head = pq->tail = NULL;
  pq->size = 0;
}
void QuenePush(Quene* pq, QDataType x)
{
  assert(pq);
  //扩容
  QNode* newnode = (QNode*)malloc(sizeof(QNode));
  if (newnode == NULL)
  {
    perror("malloc fail");
    exit(-1);
  }
  newnode->data = x;
  newnode->next = NULL;
  //第一个插入
  if (pq->head == NULL)
  {
    pq->head = pq->tail = newnode;
  }
  else
  {
    pq->tail->next = newnode;
    pq->tail = newnode;
  }
  pq->size++;
}
bool QueneEmpty(Quene* pq)
{
  assert(pq);
  return pq->head==NULL;
}
int QueneSize(Quene* pq)
{
  assert(pq);
  return pq->size;
}
void QuenePop(Quene* pq)
{
  assert(pq);
  //判断是否没有数据
  assert(!QueneEmpty(pq));
  
  
  //只有一个数据
  if (pq->head->next == NULL)
  {
    free(pq->head);
    pq->head = pq->tail = NULL;
  }
  else
  {
      QNode* next = pq->head->next;
    free(pq->head);
    pq->head = next;
  }
  pq->size--;
}
QDataType QueneFront(Quene* pq)
{
  assert(pq);
  assert(!QueneEmpty(pq));
    return pq->head->data;
}
QDataType QueneBack(Quene* pq)
{
  assert(pq);
  assert(!QueneEmpty(pq));
  return pq->tail->data;
}
typedef struct {
    Quene q1;
    Quene q2;
} MyStack;
//创建一个自己的栈
//用一个结构体进行包装
MyStack* myStackCreate() {
    MyStack* obj=malloc(sizeof(MyStack));
    QueneInit(&obj->q1);
    QueneInit(&obj->q2);
    return obj;
}
//插入判断哪个队列不为空
void myStackPush(MyStack* obj, int x) {
    if(!QueneEmpty(&obj->q2))
    {
        QuenePush(&obj->q2,x);
    }
    else
    {
        QuenePush(&obj->q1,x);
    }
}
//将队列分为空队列和不空队列
int myStackPop(MyStack* obj) {
    Quene* empty=&obj->q1;
    Quene* nonempty=&obj->q2;
    if(!QueneEmpty(&obj->q1))
    {
         empty=&obj->q2;
         nonempty=&obj->q1;
    }
  //数据转移
    while(QueneSize(nonempty)>1)
    {
        QuenePush(empty,QueneFront(nonempty));
        QuenePop(nonempty);
    }
   //删除数据，并返回
    int Top=QueneFront(nonempty);
    QuenePop(nonempty);
    return Top;
}
int myStackTop(MyStack* obj) {
    if(!QueneEmpty(&obj->q2))
    {
        return QueneBack(&obj->q2);
    }
    else
    {
        return QueneBack(&obj->q1);
    }
}
bool myStackEmpty(MyStack* obj) {
    return QueneEmpty(&obj->q1)&&QueneEmpty(&obj->q2);
}
void myStackFree(MyStack* obj) {
    QueneDestory(&obj->q1);
    QueneDestory(&obj->q2);
    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);
*/

3.用栈实现队列

思路：一样的我们先在纸上模拟

如果再继续删除，那么可以删除到栈2为空，然后就将栈1的内容全部转移到栈2；如果栈2没空，再插入栈1会发现没有任何影响；

所以我们总结得出：将栈1表示为插入的栈，栈2表示为删除的栈，如果要删除栈2为空就将栈1的内容转移到栈2；

代码：

typedef int STDataType;
typedef struct Stack
{
  STDataType* a;
  int top;
  int capacity;
}ST;
void STInit(ST* ps)
{
  assert(ps);
  ps->a = NULL;
  ps->top = 0;
  ps->capacity = 0;
}
void STDestory(ST* ps)
{
  assert(ps);
  free(ps->a);
  ps->a = NULL;
  ps->capacity = 0;
  ps->top = 0;
}
void STPush(ST* ps, STDataType x)
{
  assert(ps);
  if (ps->top == ps->capacity)
  {
    int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
    STDataType* tmp = realloc(ps->a, sizeof(STDataType) * newcapacity);
    if (tmp == NULL)
    {
      perror("Stack fail");
      exit(-1);
    }
    ps->a =tmp;
    ps->capacity = newcapacity;
  }
  ps->a[ps->top] = x;
  ps->top++;
}
void STPop(ST* ps)
{
  assert(ps);
  assert(ps->top > 0);
  ps->top--;
}
STDataType STTop(ST* ps)
{
  assert(ps);
  assert(ps->top > 0);
  return ps->a[ps->top - 1];
}
int STSize(ST* ps)
{
  assert(ps);
  return ps->top;
}
bool STEmpty(ST* ps)
{
  assert(ps);
  return ps->top==0;
}
//栈分为插入栈和输出栈
typedef struct {
    ST instack;
    ST outstack;
} MyQueue;
MyQueue* myQueueCreate() {
    MyQueue* obj=malloc(sizeof(MyQueue));
    STInit(&obj->instack);
    STInit(&obj->outstack);
    return obj;
}
void myQueuePush(MyQueue* obj, int x) {
    STPush(&obj->instack,x);
}
int myQueuePop(MyQueue* obj) {
  //先判断输出栈是否为空
    if(STEmpty(&obj->outstack))
    {
        while(STSize(&obj->instack))
        {
            STPush(&obj->outstack,STTop(&obj->instack));
            STPop(&obj->instack);
        }
    }
    int head=STTop(&obj->outstack);
    STPop(&obj->outstack);
    return head;
}
int myQueuePeek(MyQueue* obj) {
    if(STEmpty(&obj->outstack))
    {
        while(STSize(&obj->instack))
        {
            STPush(&obj->outstack,STTop(&obj->instack));
            STPop(&obj->instack);
        }
    }
    return STTop(&obj->outstack);
}
bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&obj->instack)&&STEmpty(&obj->outstack);
}
void myQueueFree(MyQueue* obj) {
    STDestory(&obj->instack);
    STDestory(&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);
*/

4.设计循环队列

我们先根据题意确定我们将选择数组来存储（固定长度）；然后考虑怎么让这个数组能够循环着走？我们可以设置两个指针来判断（由于是数组，可以利用下标来进行代表指针），分别为头和尾；假设队列长度为k，一开始，头和尾下标都为0，表示这个队列为空；

那么当插入一个元素后尾向后走一步

删除一个元素头向后走一步，

当数组填满后，会发现头尾又重叠在一起，与一开始队列为空情况是一样的，这样就无法判断空与满了；

所以我们可以再增加一个多出来的空间

当尾走到最后一个多出来的空间时就表示满；

循环的尾走到最后时我们用取模来进行返回到下标为0的位置；这样子就能完成我们循环的目的。

代码：

typedef struct {
    int* a;
    int head;
    int rear;
    int k;
    
} MyCircularQueue;
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj=malloc(sizeof(MyCircularQueue));
    obj->a=malloc(sizeof(int)*(k+1));
    obj->head=obj->rear=0;
    obj->k=k;
    return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->head==obj->rear;
}
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    //当rear超过k+1时，归0
    return (obj->rear+1)%(obj->k+1)==obj->head;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->rear]=value;
    obj->rear++;
    //限制在0-k
    obj->rear%=(obj->k+1);
    return true;
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->head++;
    //限制在0-k
    obj->head%=(obj->k+1);
    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;
    }
    //考虑rear-1等于-1的情况
    return obj->a[(obj->rear+obj->k)%(obj->k+1)];
}
void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}
/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/

这里需要注意的就是取模的问题，需要记住尾和头是不断增加的，是由于取模k+1才限制在0-k的下标中；

第一个就是在删除和插入数据的时候，当头尾超出范围时，需要进行取模k+1的操作，返回到第一个元素；

第二个是判断满时，尾+1相当于返回到头，当尾刚好处于最后下标时，需要进行取模；

最后一个是取尾的问题，当尾刚好处于第一个下标时，由于尾需要进行-1的操作才能得到尾元素，所欲在第一个下标-1会导致下标变为-1，所以可以多加一轮K+1进行取模的操作避免这个问题；

文章标签：
存储
关键词：
数据结构队列
数据结构栈队列
数据结构栈
数据结构栈和队列
诡异森林。
目录
相关文章
大数据文摘
|
8月前
|
前端开发 Java
java实现队列数据结构代码详解
本文详细解析了Java中队列数据结构的实现，包括队列的基本概念、应用场景及代码实现。队列是一种遵循“先进先出”原则的线性结构，支持在队尾插入和队头删除操作。文章介绍了顺序队列与链式队列，并重点分析了循环队列的实现方式以解决溢出问题。通过具体代码示例（如`enqueue`入队和`dequeue`出队），展示了队列的操作逻辑，帮助读者深入理解其工作机制。
大数据文摘
271 1
hahaha无
|
6月前
|
编译器 C语言 C++
栈区的非法访问导致的死循环(x64)
这段内容主要分析了一段C语言代码在VS2022中形成死循环的原因，涉及栈区内存布局和数组越界问题。代码中`arr[15]`越界访问，修改了变量`i`的值，导致`for`循环条件始终为真，形成死循环。原因是VS2022栈区从低地址到高地址分配内存，`arr`数组与`i`相邻，`arr[15]`恰好覆盖`i`的地址。而在VS2019中，栈区先分配高地址再分配低地址，因此相同代码表现不同。这说明编译器对栈区内存分配顺序的实现差异会导致程序行为不一致，需避免数组越界以确保代码健壮性。
hahaha无
135 0
栈区的非法访问导致的死循环(x64)
游客beejssedmb2sq
|
6月前
232.用栈实现队列，225. 用队列实现栈
在232题中，通过两个栈（`stIn`和`stOut`）模拟队列的先入先出（FIFO）行为。`push`操作将元素压入`stIn`，`pop`和`peek`操作则通过将`stIn`的元素转移到`stOut`来实现队列的顺序访问。 225题则是利用单个队列（`que`）模拟栈的后入先出（LIFO）特性。通过多次调整队列头部元素的位置，确保弹出顺序符合栈的要求。`top`操作直接返回队列尾部元素，`empty`判断队列是否为空。 两题均仅使用基础数据结构操作，展示了栈与队列之间的转换逻辑。
游客beejssedmb2sq
162 0
RossyYan
|
11月前
|
存储 C语言 C++
【C++数据结构——栈与队列】顺序栈的基本运算（头歌实践教学平台习题）【合集】
本关任务：编写一个程序实现顺序栈的基本运算。开始你的任务吧，祝你成功！​ 相关知识 初始化栈 销毁栈 判断栈是否为空 进栈 出栈 取栈顶元素 1.初始化栈 概念：初始化栈是为栈的使用做准备，包括分配内存空间（如果是动态分配）和设置栈的初始状态。栈有顺序栈和链式栈两种常见形式。对于顺序栈，通常需要定义一个数组来存储栈元素，并设置一个变量来记录栈顶位置；对于链式栈，需要定义节点结构，包含数据域和指针域，同时初始化栈顶指针。 示例（顺序栈）： 以下是一个简单的顺序栈初始化示例，假设用C语言实现，栈中存储
RossyYan
543 77
蓝易云
|
10月前
|
算法 调度 C++
STL——栈和队列和优先队列
通过以上对栈、队列和优先队列的详细解释和示例，希望能帮助读者更好地理解和应用这些重要的数据结构。
蓝易云
247 11
羑悻的小杀马特
|
10月前
|
DataX
☀☀☀☀☀☀☀有关栈和队列应用的oj题讲解☼☼☼☼☼☼☼
### 简介 本文介绍了三种数据结构的实现方法：用两个队列实现栈、用两个栈实现队列以及设计循环队列。具体思路如下： 1. **用两个队列实现栈**： - 插入元素时，选择非空队列进行插入。 - 移除栈顶元素时，将非空队列中的元素依次转移到另一个队列，直到只剩下一个元素，然后弹出该元素。 - 判空条件为两个队列均为空。 2. **用两个栈实现队列**： - 插入元素时，选择非空栈进行插入。 - 移除队首元素时，将非空栈中的元素依次转移到另一个栈，再将这些元素重新放回原栈以保持顺序。 - 判空条件为两个栈均为空。
羑悻的小杀马特
177 14
RossyYan
|
11月前
|
存储 C++ 索引
【C++数据结构——栈与队列】环形队列的基本运算（头歌实践教学平台习题）【合集】
【数据结构——栈与队列】环形队列的基本运算（头歌实践教学平台习题）【合集】初始化队列、销毁队列、判断队列是否为空、进队列、出队列等。本关任务：编写一个程序实现环形队列的基本运算。(6)出队列序列:yzopq2*(5)依次进队列元素:opq2*(6)出队列序列:bcdef。(2)依次进队列元素:abc。(5)依次进队列元素:def。(2)依次进队列元素:xyz。开始你的任务吧，祝你成功！(4)出队一个元素a。(4)出队一个元素x。
RossyYan
455 13
【C++数据结构——栈与队列】环形队列的基本运算（头歌实践教学平台习题）【合集】
RossyYan
|
11月前
|
C++
【C++数据结构——栈和队列】括号配对（头歌实践教学平台习题）【合集】
【数据结构——栈和队列】括号配对（头歌实践教学平台习题）【合集】（1）遇到左括号：进栈Push()（2）遇到右括号：若栈顶元素为左括号，则出栈Pop()；否则返回false。（3）当遍历表达式结束，且栈为空时，则返回true，否则返回false。本关任务：编写一个程序利用栈判断左、右圆括号是否配对。为了完成本关任务，你需要掌握：栈对括号的处理。（1）遇到左括号：进栈Push()开始你的任务吧，祝你成功！测试输入：(()))
RossyYan
257 7
ephemerals__
|
C语言
【数据结构】栈和队列（c语言实现）（附源码）
本文介绍了栈和队列两种数据结构。栈是一种只能在一端进行插入和删除操作的线性表，遵循“先进后出”原则；队列则在一端插入、另一端删除，遵循“先进先出”原则。文章详细讲解了栈和队列的结构定义、方法声明及实现，并提供了完整的代码示例。栈和队列在实际应用中非常广泛，如二叉树的层序遍历和快速排序的非递归实现等。
ephemerals__
1044 9
那年春天
|
存储 算法
非递归实现后序遍历时，如何避免栈溢出？
后序遍历的递归实现和非递归实现各有优缺点，在实际应用中需要根据具体的问题需求、二叉树的特点以及性能和空间的限制等因素来选择合适的实现方式。
那年春天
302 59

热门文章

最新文章

  • 1
    （Python基础）新时代语言！一起学习Python吧！（一）：认识Python、Py解释器作用；编写第一个Python程序；Python中的基本数据结构
  • 2
    （Pandas）Python做数据处理必选框架之一！（一）：介绍Pandas中的两个数据结构；刨析Series：如何访问数据；数据去重、取众数、总和、标准差、方差、平均值等；判断缺失值、获取索引...
  • 3
    【数据结构】二叉树（c语言）（附源码）
  • 4
    栈和队列的区别
  • 5
    如何遍历文件夹下上亿文件而不栈溢出
  • 6
    数据结构面试之九——图的常见操作3之最小生成树
  • 7
    栈的压入、弹出序列
  • 8
    包含min函数的栈和两个栈实现一个队列
  • 9
    Redis部分数据结构方法小结
  • 10
    数据结构与算法——字符串
  • 1
    （Pandas）Python做数据处理必选框架之一！（一）：介绍Pandas中的两个数据结构；刨析Series：如何访问数据；数据去重、取众数、总和、标准差、方差、平均值等；判断缺失值、获取索引...
    432
  • 2
    （Python基础）新时代语言！一起学习Python吧！（一）：认识Python、Py解释器作用；编写第一个Python程序；Python中的基本数据结构
    429
  • 3
    Redis数据结构：别小看这5把“瑞士军刀”，用好了性能飙升！
    382
  • 4
    软考中级软件设计师专项-数据结构与算法上篇
    513
  • 5
    【Redis】常用数据结构之List篇：从常用命令到典型使用场景
    470
  • 6
    Redis基础命令与数据结构概览
    123
  • 7
    Redis各类数据结构详细介绍及其在Go语言Gin框架下实践应用
    302
  • 8
    【Redis】 常用数据结构之String篇：从SET/GET到INCR的超全教程
    346
  • 9
    【📕分布式锁通关指南 12】源码剖析redisson如何利用Redis数据结构实现Semaphore和CountDownLatch
    305
  • 10
    Redis核心数据结构与分布式锁实现详解
    353

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法

    • 相关电子书

    更多
  • 如何使用Tair增强数据结构构建丰富在线实时场景
  • Apache Flink 流式应用中状态的数据结构定义升级
  • 低代码开发师（初级）实战教程
    • 下一篇
    阿里云服务器快照备份数据怎么下载到本地保存？