栈和队列--oj题

已于 2023-04-13 10:12:25 修改
阅读量59 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 经验分享
于 2023-04-12 20:07:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74206992/article/details/130110037
版权

目录

用栈实现队列

1.题目链接

2.题目描述

3.题目分析

4.代码实现

用队列实现栈

1.题目链接

2.题目描述

3.题目分析

4.代码实现

设计循环队列

1.题目链接

2.题目描述

3.题目分析

4.代码实现

用栈实现队列

1.题目链接

232. 用栈实现队列 - 力扣（LeetCode）

2.题目描述

3.题目分析 

图的上部分是我们要模拟出来的队列,下部分是两个栈

  • 我们首先选定一个栈作为入口

  •  但我们如果直接用栈出数据,得到的是3,为了得到需要的1,就将第一个栈的数据全部导入另一个栈中,之后在第二个栈中进行出栈即可

  •  如果我们继续出栈,可以直接在第二个栈中操作,此时它里面的数据顺序恰好为队列出栈顺序
  • 但若要入栈,则必须在第一个栈中进行,否则会扰乱数据顺序

  •  当第二个栈无数据时,就需要像前面那样,将第一个栈的数据导在里面

4.代码实现

#define MALLOC(type,num) (type*)malloc(num*sizeof(type))
#define REALLOC(obj,type,num) (type*)realloc(obj,num*sizeof(type))

typedef struct stack{
    int* data;  //用顺序表模拟栈
    int top;  //下一个栈顶元素的下标大小(也是栈顶元素的个数)
    int capacity;  //容量,当元素个数超过容量时,需要扩容
}node;
typedef struct {  //因为下面的函数中只传入了一个指针,所以需要用
                  //该指针管控两个设定的栈类型的指针
    node* stack1;
    node* stack2;
} MyQueue;

MyQueue* myQueueCreate() { //初始化
   MyQueue* obj=MALLOC(MyQueue,1);
   obj->stack1=MALLOC(node,1);
   obj->stack1->data=MALLOC(int,5);
   obj->stack1->capacity=5;
   obj->stack1->top=0;

   obj->stack2=MALLOC(node,1);
   obj->stack2->data=MALLOC(int,5);
   obj->stack2->capacity=5;
   obj->stack2->top=0;
   return obj;
}

void myQueuePush(MyQueue* obj, int x) {
    if(obj->stack1->top==obj->stack1->capacity){ //扩容
        int* tmp=REALLOC(obj->stack1->data,int,obj->stack1->capacity*2);
        obj->stack1->capacity*=2;
        obj->stack1->data=tmp;
    }
    obj->stack1->data[obj->stack1->top++]=x; //入1号栈
}

int myQueuePop(MyQueue* obj) {
    if(obj->stack2->top>0){  //如果2中还有元素,就直接出
        obj->stack2->top--;
        return obj->stack2->data[obj->stack2->top];
    }
    //没有元素,需要将1中数据导入2
    int tmp=obj->stack1->top;  //1中元素个数
    while(tmp--){
        obj->stack2->data[obj->stack2->top++]=obj->stack1->data[--obj->stack1->top];  //导入2中
    }
    int t=obj->stack2->data[obj->stack2->top-1];  //出2号栈
    obj->stack2->top--;
    return t;
}

int myQueuePeek(MyQueue* obj) {
    if(obj->stack2->top>0){
        return obj->stack2->data[obj->stack2->top-1];
    }
    
    int tmp=obj->stack1->top;  //1中元素个数
    while(tmp--){
        obj->stack2->data[obj->stack2->top++]=obj->stack1->data[--obj->stack1->top];  //导入2中
    }
    int t=obj->stack2->data[obj->stack2->top-1];
    return t;
}

bool myQueueEmpty(MyQueue* obj) {
    return ((obj->stack1->top==0)&&(obj->stack2->top==0)); //两个栈都为空时,才为队列空
}

void myQueueFree(MyQueue* obj) {
    free(obj->stack1->data);
    free(obj->stack2->data);
    free(obj->stack1);
    free(obj->stack2);
}

用队列实现栈

1.题目链接

225. 用队列实现栈 - 力扣（LeetCode）

2.题目描述

3.题目分析

图的右边是我们要模拟出来的栈,左边是两个队列

  • 我们首先选定一个队列入数据(在栈中入数据是右边这样)

  •  如果要出数据的话,我们需要出3,但由队列出的数据是1

  •  因此将1,2出队,进入到第二个队列中

 等第一个队列出3后,第一个队列就空了

  • 如果继续出栈,则需要将不为空的队列的前n-1个数据导入空队列,剩下一个直接在原队列出队

  • 如果要入栈,则直接在不为空的队列入即可,因为队列在导入的过程中并没有改变原顺序

4.代码实现

#define MALLOC(type,num) (type*)malloc(num*sizeof(type))
#define REALLOC(obj,type,num) (type*)realloc(obj,num*sizeof(type))

typedef struct node{
    int* data; //用顺序表模拟队列
    int head;
    int tail;  //数值为队列中的元素数量
    int capacity;  //容量
}node;
typedef struct {
    node* queue1;
    node* queue2;
} MyStack;

MyStack* myStackCreate() {//初始化
   MyStack* obj=MALLOC(MyStack,1);
   obj->queue1=MALLOC(node,1);
   obj->queue1->data=MALLOC(int,5);
   obj->queue1->capacity=5;
   obj->queue1->head=obj->queue1->tail=0;

   obj->queue2=MALLOC(node,1);
   obj->queue2->data=MALLOC(int,5);
   obj->queue2->capacity=5;
   obj->queue2->head=obj->queue2->tail=0;
   return obj;
}
bool Empty(node* q){ //判断哪个队列为空,为空返回真
    return (q->tail==0);
}
void myStackPush(MyStack* obj, int x) { 
    node* emp=obj->queue1,*nonemp=obj->queue2; //假设1为空,2不为空
    if(Empty(obj->queue2)&&(!Empty(obj->queue1))){ //如果2为空且1不为空(防止都为空的情况),就修改指针内容
        emp=obj->queue2;
        nonemp=obj->queue1;
    }
    if(nonemp->tail==nonemp->capacity){  //入在不为空的队列里(即使都为空,也可以入成功)
    //不够时进行扩容
        int* tmp=REALLOC(nonemp->data,int,nonemp->capacity*2);
        nonemp->capacity*=2;
        nonemp->data=tmp;
    }
    nonemp->data[nonemp->tail++]=x;
}
bool myStackEmpty(MyStack* obj) {  //两个队列都为空时,才为空
    return (obj->queue1->tail==0)&&(obj->queue2->tail==0);
}
int myStackPop(MyStack* obj) {  //要出不为空的队列
    node* emp=obj->queue1,*nonemp=obj->queue2;
    if(Empty(obj->queue2)&&(!Empty(obj->queue1))){
        emp=obj->queue2;
        nonemp=obj->queue1;
    }

    if(!myStackEmpty(obj)){
        int t=nonemp->tail-1;
        int ans=nonemp->data[t]; //先将要返回的栈顶元素(即非空队列最后一个元素)保存住
        while(t--){ //将n-1个元素导出到空队列
            emp->data[emp->tail]=nonemp->data[emp->tail];
            emp->tail++;//使先前的空队列元素+1
            nonemp->tail--;  //使先前的非空队列元素-1
            if(emp->tail==emp->capacity){ //扩容,因为emp正在加元素
                int* tmp=REALLOC(emp->data,int,emp->capacity*2);
                emp->capacity*=2;
                emp->data=tmp;
            }
        }
        nonemp->tail--; //因为最后还剩下一个元素,直接将tail-1即可
        //因为之前ans已经保存了该元素的值
        return ans;
    }   
    return 0;
}

int myStackTop(MyStack* obj) {  
    if(!myStackEmpty(obj)){
        node* emp=obj->queue1,*nonemp=obj->queue2; //还是之前的操作,找到非空队列,
        //直接返回最后一个元素
        if(Empty(obj->queue2)&&(!Empty(obj->queue1))){
        emp=obj->queue2;
        nonemp=obj->queue1;
        }
        int t=nonemp->tail-1;
        int ans=nonemp->data[t];
        return ans;
    }
    return 0;
}

void myStackFree(MyStack* obj) {
    free(obj->queue1->data);
    free(obj->queue1);
    free(obj->queue2->data);
    free(obj->queue2);
}

设计循环队列

1.题目链接

622. 设计循环队列 - 力扣（LeetCode）

2.题目描述

3.题目分析

  • 因为循环队列的容量是固定的,因此不需要扩容操作
  • 由于是循环,并且我们是用下标访问,因此在入队和出队时需要处理下标(只要当他出范围时,赋为0即可,或者取余数也可)

4.代码实现

#define MALLOC(type,num) (type*)malloc(sizeof(type)*num)
typedef struct {
    int* data;
    int head; //记录起始下标
    int tail; //记录最后一个元素的下一个下标
    int size;  //元素个数
    int capacity;  //容量,这里无法扩容,因为循环队列容量是固定的
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {  //初始化
    MyCircularQueue* obj=MALLOC(MyCircularQueue,1);
    obj->data=MALLOC(int,k+1);
    obj->head=0;
    obj->tail=0;obj->size=0;
    obj->capacity=k;
    return obj;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(obj->size==obj->capacity){  //当队列已满,则不能添加数据了
        return false;
    }
    if(obj->tail==obj->capacity){   //如果尾指针向右移动至数组外,需要将其移动至0处
        //(会出现这种情况的原因是:满队列的情况下进行出队,就有空元素了,
        //也就需要tail++,但tail需要保持在数组下标的范围内)
        obj->tail=0;
    }
    //入队
    obj->data[obj->tail]=value;  
    obj->tail++;
    obj->size++;  
    return true;
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(obj->size==0){  //如果队列内无元素,就不能出队了
        return false;
    }
    obj->data[obj->head]=0;
    obj->head++;
    if(obj->head==obj->capacity){ //放在后面处理是为了及时将head控制在合理的范围内.防止其他函数使用head时出现越界访问
        obj->head=0;
    }
    obj->size--;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(obj->size==0){
        return -1;
    }
    return obj->data[obj->head]; //head所在位置就是队头元素
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(obj->size==0){
        return -1;
    }
    int ans;
    if(obj->tail==0){  //这里要分情况,如果不分的话,当tail=0时,
        //我们需要的是tail-1所在的元素,但-1不在合理范围内
        ans=obj->capacity-1;  //因此按照逻辑,此时的队尾元素应该是capacity-1所在位置
    }
    else{
        ans=obj->tail-1; 
    }
    return obj->data[ans];
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    if(obj->size==0){  //直接用size判断,简单又快捷
        return true;
    }
    return false;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    if(obj->size==obj->capacity){
        return true;
    }
    return false;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->data);
    free(obj);
}

沐风ya
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【剑指Offer面试编程题】题目1512：用两个栈实现队列--九度OJ
一路向前
12-18 549
新建栈st1模拟队列的输入，只要遇到push操作，都将元素压入st1中。另外，新建栈st2模拟队列的输出，如果pop操作时，先判断st1是否为空，当st2为空，则将st1的中的所有元素挨个弹出并压入st2中以备输出，这时的st2中的元素的排列正好是当前所有元素的输入的逆序，符合队列的输出顺序；-->>当出现pop操作时，如果st2不为空，这个时候的栈顶元素真好是当前状态的队列的头元素，则直接弹出栈顶元素作为队列的输出。
leetcode和oj-leetcode-oj:leetcode
06-30
和 oj leetcode-oj leetcode 使用 vue.js 的解决方案 构建设置 # install dependencies npm install # serve with hot reload at localhost:8080 npm run dev # build for production with minification npm run ...
栈和队列OJ题：LeetCode--232.用栈实现队列
Yikefore的博客
05-20 1224
LeetCode--232.用栈实现队列：详细题解以及图解和完整代码。
栈和队列常见oj题
weixin_59551524的博客
02-16 735
栈和队列 栈是先进后出（在栈顶进行删除和插入），所以你可以用在一些特殊的地方，比如逆序打印链表等等。 比如判断栈出数据的顺序，中缀表达式 转 后缀表达式 （后缀表达式也叫作逆波兰表达式） 现将转换成后缀表达式，通过这个表达式去计算。那么如何去转换成后缀表达式 需要用到栈 栈中的一些方法，可以查看api，比较常用的：peek,pop,push,isEmpty，search public static void main(String[] args) { MyStack s
每日一题---OJ题: 用栈实现队列
qq_74336191的博客
04-18 781
这里，我先把有关栈的代码放出来哈~栈的头文件 Stack.hint top;}Stack;//初始化栈//入栈//出栈//获取栈顶元素//获取栈中有效元素的个数//检测栈是否为空//销毁栈栈的具体操作 Stack.c//初始化栈assert(st);//入栈assert(st);//扩容\n");exit(1);st->top++;//出栈assert(st);= 0);st->top--;//获取栈顶元素assert(st);
两个队列模拟栈-OJ题
qq_58724706的博客
11-03 246
目录 题目描述 示例 提示 题目分析 结构体的创建 函数接口 void myStackPush(MyStack* obj, int x) int myStackPop(MyStack* obj) int myStackTop(MyStack* obj) bool myStackEmpty(MyStack* obj) void myStackFree(MyStack* obj) 完整代码 题目描述 请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种..
栈和队列OJ题：LeetCode--225.用队列实现栈
Yikefore的博客
05-19 843
LeetCode--225.用队列实现栈：详细题解以及图解和完整代码。
栈和队列---栈(Stack)
你们的伟仔的博客
11-23 85
本节目标：1.栈的概念及使用 2.队列的概念及使用 3.相关OJ题
栈和队列的实现以及OJ题讲解
bushibrnxiaohaij的博客
08-06 724
👀👀👀👀👀👀🌹欢迎大家三连关注，一起学习，一起进步！！💓。
栈和队列OJ题
2302_80105876的博客
05-20 708
如果要用队列实现栈的话，使用一个队列是肯定不行的，队列结构是先进先出，栈结构是先进后出，所以我们要做的就是使用两个队列实现元素的先进后出的功能，要实现出栈操作我们只要，把左边栈的元素逐个导入右边队列中，直到剩下最后一个，再将它取出相当于出队操作。End和Head指向同一位置的时候栈为空的情况，比如原来队列需要的是k个空间，那么我们可以创建k+1个空间，那么我们就可以。用栈实现队列也就是使用栈来实现先进先出的效果，该操作用一个栈是无法完成的，我们考虑用两个栈，栈a用来模拟入队操作，栈b来模拟出队操作。
BJFU-2022-OJ
06-29
BJFU-OJ实验
leetcode和oj-LeetCode-OJ:LeetCode-OJ
06-30
和 oj LeetCode-OJ 问题 # 标题 困难 标签 0233 数字一 中等的 数学 0229 多数元素 II 中等的 大批 0224 基本计算器 中等的 数学/堆栈 0216 组合和III 中等的 数组/回溯 0209 最小尺寸子阵列总和 中等的 数组/两个...
Pa1-3-2_oj_SuperExam_mooc_PA1-3_
10-02
某英语课共有n 位学生，每位学生都有一个属于自己的整数学号。注意这一次由于课程的扩容，学生的人数非常多。　现在这门英语课准备进行期末考试，考试的形式是：每个学生单独与老师进行一段时间的口语对话。...
hihocoder和leetcode-OJPractice:OJ实践
07-06
hihocoder和leetcode OJPractice ##文件夹组织方式（暂定）： 一级文件夹按照题库组织，即分别建立Hihocoder、Leetcode、POJ等文件夹 二级文件夹命名格式为： 题号_人名ID[_语言] ，如果语言不是C/C++请添加“_语言...
初阶数据结构之双向链表详解
2302_80837091的博客
05-18 1059
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表，因此，本节的双向链表也是双向循环链表。在List.h中定义链表结点，data的类型设为DataType,方便以后使用其他类型的数据。}ListNode;
P6【力扣144，94，145】【数据结构】【二叉树遍历】C++版
最新发布
qq_50891451的博客
05-22 458
从根节点开始遍历，并将根节点入栈，再遍历他的左子树，并依次入栈，直到该结点没有左子树。判断这个结点是否有右子树，如果没有，则将该结点弹出栈，并记录结点值。如果有则继续从他的右子树进行遍历，同时记录该结点的右子树是否遍历过，如果遍历过，则弹栈并记录结点值。时间复杂度：O（N）每个结点会遍历一次且只遍历一次。空间复杂度：O（N）栈至多会存放所有树节点。
数据结构中时间复杂度的介绍
gygkhd的博客
05-17 809
在计算机科学领域，特别是在数据结构和算法的研究中，时间复杂度是一个非常关键的概念。它表示一个算法执行完成所需要的计算工作量。了解时间复杂度有助于预测程序运行的速度和效率，这对于优化程序和解决大规模数据处理问题尤为重要。时间复杂度通常用大O符号（O-notation）来表示，它描述了算法性能与输入数据之间的关系。大O符号忽略了常数和低阶项，只关注程序执行时间随输入数据规模增长的变化趋势。例如，时间复杂度为O(n)的算法表示执行时间与输入数据的规模成线性关系。
【数据结构】堆（Heep）
SWsunlight的博客
05-17 1117
堆、堆的实现
CCF OJ 1113-括号匹配[栈]
06-09
这是一个栈的经典应用，可以通过栈来判断括号是否匹配。具体做法是遍历字符串，如果遇到左括号则入栈，如果遇到右括号，则判断栈顶元素是否为对应的左括号，如果是则出栈，否则返回false。最后判断栈是否为空，如果...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值