两个队列模拟实现栈

已于 2023-05-01 21:19:44 修改
阅读量5.2k 收藏 22
点赞数 11
分类专栏： 数据结构 文章标签： 数据结构
于 2022-03-25 15:34:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63020222/article/details/123735378
版权

一、实现原理

队列：先进先出

栈：后进先出

        根据栈和队列各自的特性，这里采用两个队列模拟实现栈，其实现原理和用栈模拟实现队列差不多，但稍微复杂一点点。

假设用q1模拟入栈，q2模拟出栈，且现在q1内已经入栈了一些数据如图：

（1）出栈

        根据栈后进先出的特点，此时若要出栈，拿到的应该是a4，所以需要将a1,a2,a3先依次出队再入队到q2中，才能拿到a4。

那么完成一次出栈操作后，栈内的情况应该是如下：

        如果再进行出栈，操作和之前一样，将队列不为空的前n-1一个元素依次出队再入队到另一个空队列中即可。

（2）入栈

        若要进行入栈操作，则只需要将元素入队到不为空的队列中即可。

（3）获取栈顶

        获取栈顶元素时，我们不需要在进行如上的出队入队操作，只需直接返回不为空的队列的队尾元素即可。

（4）判空与判满

        对于栈的判空和判满操作，只需判断栈内部两个队列的空满情况即可，要注意的是，队列一个为满即栈满，队列两个都为空，栈为空。

（5）操作总结

1.入栈：将元素入队到不为空的队列当中（若初始两个队列都为空，则只需任意入队到一个队列中即可）

2.出栈：将不为空的队列的前n-1一个元素依次出队再入队到另一个空队列中，最后一个元素只出队不入队即可。（前提：栈不为空）

3.获取栈顶：返回不为空的队列的队尾即可。（前提：栈不为空）

4.栈判空：栈内两个队列都为空即栈为空。

5.栈判满：栈内不为空的队列为满，即栈为满。

6.获取栈内有效元素个数：直接返回不为空的队列内元素个数即可。

7.栈销毁：先销毁掉栈内两个队列，再销毁栈即可。

二、结构体定义

typedef int ElemType;
#define MaxSize 10//栈最大容量
typedef struct {//循环队列
    ElemType* array;
    int front;
    int rear;
    int size;//有效元素个数
}MyQueue;

typedef struct {//队列实现栈
    MyQueue* s1;
    MyQueue* s2;
} MyStack;

三、接口模拟实现

void Test_Stack();//测试函数
bool myStackEmpty(MyStack* obj);//栈判空
MyStack* myStackCreate();//栈初始化
void myStackPush(MyStack* obj, int x);//入栈
int myStackPop(MyStack* obj);//获取栈顶元素并出栈
int myStackTop(MyStack* obj);//获取栈顶元素
int StackSize(MyStack* obj);//获取栈内有效元素个数
void myStackFree(MyStack* obj);//栈销毁

1.栈初始化

MyStack* myStackCreate() {//栈初始化
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    if (obj == NULL) {//申请失败
        assert(0);
        return NULL;
    }
    obj->s1 = (MyQueue*)malloc(sizeof(MyQueue));
    obj->s2 = (MyQueue*)malloc(sizeof(MyQueue));
    if (obj->s1 == NULL || obj->s2 == NULL) {//申请失败
        assert(0);
        return NULL;
    }
    obj->s1->array = (ElemType*)malloc(sizeof(ElemType) * (MaxSize + 1));//申请MaxSize+1个空间
    obj->s2->array = (ElemType*)malloc(sizeof(ElemType) * (MaxSize + 1));
    if (obj->s1->array == NULL || obj->s2->array == NULL) {//申请失败
        assert(0);
        return NULL;
    }
    obj->s1->front = obj->s1->rear = obj->s1->size = 0;
    obj->s2->front = obj->s2->rear = obj->s2->size = 0;
    return obj;
}

2.入栈

void myStackPush(MyStack* obj, int x) {//入栈
    assert(obj);
    if (obj->s1->size == 0 && obj->s2->size == 0) {//两个队列都为空，入栈到队列s1中
        obj->s1->array[obj->s1->rear] = x;
        obj->s1->rear = (obj->s1->rear + 1) % MaxSize;
        obj->s1->size++;
        return;
    }
    if (obj->s1->size == 0 && obj->s2->size) {//s1为空,s2不为空，则入栈到队列s2中
        if (obj->s2->size == MaxSize) {//栈满（队满）
            return;
        }
        obj->s2->array[obj->s2->rear] = x;
        obj->s2->rear = (obj->s2->rear + 1) % MaxSize;
        obj->s2->size++;
    }
    else {//s2为空,s1不为空，则入栈到队列s1中
        if (obj->s1->size == MaxSize) {//栈满（队满）
            return;
        }
        obj->s1->array[obj->s1->rear] = x;
        obj->s1->rear = (obj->s1->rear + 1) % MaxSize;
        obj->s1->size++;
    }
}

        先判断是否栈为空（两个队列都为空），为空则入队到任意一个队列内即可，不为空则判断并入队到不为空的队列中即可。（入队前需先对队列进行判满操作）

3.获取栈顶元素并出栈

int myStackPop(MyStack* obj) {//获取栈顶元素并出栈
    assert(obj);
    if (myStackEmpty(obj)) {//栈判空
        return -1;
    }
    ElemType temp = 0;
    //将不为空的哪个队列的前size-1个元素入队到空队列中，第size个元素即为栈顶
    if (obj->s1->size && obj->s2->size == 0) {//s1不为空
        int flag = obj->s1->size - 1;
        for (int i = 0; i < flag; i++) {
            obj->s2->array[obj->s2->rear] = obj->s1->array[obj->s1->front];
            obj->s2->rear = (obj->s2->rear + 1) % MaxSize;
            obj->s2->size++;
            obj->s1->front = (obj->s1->front + 1) % MaxSize;
            obj->s1->size--;
        }
        temp = obj->s1->array[obj->s1->front];//保存栈顶元素（队尾元素）
        obj->s1->front = (obj->s1->front + 1) % MaxSize;//出栈
        obj->s1->size--;
    }
    else {//s2不为空
        int flag = obj->s2->size - 1;
        for (int i = 0; i < flag; i++) {
            obj->s1->array[obj->s1->rear] = obj->s2->array[obj->s2->front];
            obj->s1->rear = (obj->s1->rear + 1) % MaxSize;
            obj->s1->size++;
            obj->s2->front = (obj->s2->front + 1) % MaxSize;
            obj->s2->size--;
        }
        temp = obj->s2->array[obj->s2->front];//保存栈顶元素（队尾元素）
        obj->s2->front = (obj->s2->front + 1) % MaxSize;//出栈
        obj->s2->size--;
    }
    return temp;//返回栈顶元素
}

        用队列模拟栈的操作中，相对比较复杂的就是出栈操作了。但其原理其实也是比较简单的，先判断是否是空栈（即两个队列都为空），为空则无需操作，不为空则只需将不为空的队列内的前n-1个元素依次出队再入队到另一个空队列中即可，最后第n个元素即为栈顶元素，对其1只出队不入队即出栈成功。

4.获取栈顶元素

int myStackTop(MyStack* obj) {//获取栈顶元素
    assert(obj);
    if (myStackEmpty(obj)) {//栈判空
        return -1;
    }
    if (obj->s1->size && obj->s2->size == 0) {//s1不为空，s2为空
        return obj->s1->array[(obj->s1->rear - 1 + MaxSize) % MaxSize];//直接返回队尾元素即栈顶元素
    }
    else {
        return obj->s2->array[(obj->s2->rear - 1 + MaxSize) % MaxSize];
    }
}

        栈不为空则直接返回不为空的队列的队尾元素即可。需注意的是，队尾元素为rear-1号下标的元素，而且为了避免队列的假溢出问题，我采用的是循环队列，为了防止数组越界，每次对队头队尾直接操作时，都需要对最大容量进行取余。

5.栈判空

bool myStackEmpty(MyStack* obj) {//栈判空
    if (obj->s1->size == 0 && obj->s2->size == 0) {//两个队列都为空，即栈为空
        return true;
    }
    return false;
}

        栈内两个队列都为空即栈为空。

6.获取栈内有效元素个数

int StackSize(MyStack* obj) {//获取栈内有效元素个数
    assert(obj);
    return obj->s1->size > obj->s2->size ? obj->s1->size : obj->s2->size;
}

7.栈销毁

void myStackFree(MyStack* obj) {//栈销毁
    assert(obj);
    if (obj) {
        free(obj->s1->array);
        free(obj->s1);
        free(obj->s2->array);
        free(obj->s2);
        free(obj);
    }
}

四、接口测试

1.测试函数

void Test_Stack() {
    MyStack* s = myStackCreate();//初始化
    myStackPush(s, 1);//入栈
    myStackPush(s, 2);
    myStackPush(s, 3);
    myStackPush(s, 4);

    printf("top=%d\n", myStackPop(s));//获取栈顶元素4并出栈
    printf("bool=%d\n", myStackEmpty(s));//判空 bool=0
    printf("size=%d\n", StackSize(s));//获取有效元素个数3
    printf("top=%d\n", myStackPop(s));//获取栈顶元素3并出栈
    printf("top=%d\n", myStackTop(s));//获取栈顶元素2
    printf("top=%d\n", myStackPop(s));//获取栈顶元素2并出栈
    printf("top=%d\n", myStackPop(s));//获取栈顶元素1并出栈
    printf("size=%d\n", StackSize(s));//获取有效元素个数0
    printf("bool=%d\n", myStackEmpty(s));//判空 bool=1

    myStackFree(s);//栈销毁
}

2.测试结果

 五、完整代码

#include<stdio.h>
#include<assert.h>
#include<stdbool.h>
#include<malloc.h>

typedef int ElemType;
#define MaxSize 10//栈最大容量
typedef struct {//循环队列
    ElemType* array;
    int front;
    int rear;
    int size;//有效元素个数
}MyQueue;

typedef struct {//队列实现栈
    MyQueue* s1;
    MyQueue* s2;
} MyStack;

void Test_Stack();//测试函数
bool myStackEmpty(MyStack* obj);//栈判空
MyStack* myStackCreate();//栈初始化
void myStackPush(MyStack* obj, int x);//入栈
int myStackPop(MyStack* obj);//获取栈顶元素并出栈
int myStackTop(MyStack* obj);//获取栈顶元素
int StackSize(MyStack* obj);//获取栈内有效元素个数
void myStackFree(MyStack* obj);//栈销毁

int main() {
    Test_Stack();
    return 0;
}

void Test_Stack() {
    MyStack* s = myStackCreate();//初始化
    myStackPush(s, 1);//入栈
    myStackPush(s, 2);
    myStackPush(s, 3);
    myStackPush(s, 4);

    printf("top=%d\n", myStackPop(s));//获取栈顶元素4并出栈
    printf("bool=%d\n", myStackEmpty(s));//判空 bool=0
    printf("size=%d\n", StackSize(s));//获取有效元素个数3
    printf("top=%d\n", myStackPop(s));//获取栈顶元素3并出栈
    printf("top=%d\n", myStackTop(s));//获取栈顶元素2
    printf("top=%d\n", myStackPop(s));//获取栈顶元素2并出栈
    printf("top=%d\n", myStackPop(s));//获取栈顶元素1并出栈
    printf("size=%d\n", StackSize(s));//获取有效元素个数0
    printf("bool=%d\n", myStackEmpty(s));//判空 bool=1

    myStackFree(s);//栈销毁
}

MyStack* myStackCreate() {//栈初始化
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    if (obj == NULL) {//申请失败
        assert(0);
        return NULL;
    }
    obj->s1 = (MyQueue*)malloc(sizeof(MyQueue));
    obj->s2 = (MyQueue*)malloc(sizeof(MyQueue));
    if (obj->s1 == NULL || obj->s2 == NULL) {//申请失败
        assert(0);
        return NULL;
    }
    obj->s1->array = (ElemType*)malloc(sizeof(ElemType) * (MaxSize + 1));//申请MaxSize+1个空间
    obj->s2->array = (ElemType*)malloc(sizeof(ElemType) * (MaxSize + 1));
    if (obj->s1->array == NULL || obj->s2->array == NULL) {//申请失败
        assert(0);
        return NULL;
    }
    obj->s1->front = obj->s1->rear = obj->s1->size = 0;
    obj->s2->front = obj->s2->rear = obj->s2->size = 0;
    return obj;
}

void myStackPush(MyStack* obj, int x) {//入栈
    assert(obj);
    if (obj->s1->size == 0 && obj->s2->size == 0) {//两个队列都为空，入栈到队列s1中
        obj->s1->array[obj->s1->rear] = x;
        obj->s1->rear = (obj->s1->rear + 1) % MaxSize;
        obj->s1->size++;
        return;
    }
    if (obj->s1->size == 0 && obj->s2->size) {//s1为空,s2不为空，则入栈到队列s2中
        if (obj->s2->size == MaxSize) {//栈满（队满）
            return;
        }
        obj->s2->array[obj->s2->rear] = x;
        obj->s2->rear = (obj->s2->rear + 1) % MaxSize;
        obj->s2->size++;
    }
    else {//s2为空,s1不为空，则入栈到队列s1中
        if (obj->s1->size == MaxSize) {//栈满（队满）
            return;
        }
        obj->s1->array[obj->s1->rear] = x;
        obj->s1->rear = (obj->s1->rear + 1) % MaxSize;
        obj->s1->size++;
    }
}

int myStackPop(MyStack* obj) {//获取栈顶元素并出栈
    assert(obj);
    if (myStackEmpty(obj)) {//栈判空
        return -1;
    }
    ElemType temp = 0;
    //将不为空的哪个队列的前size-1个元素入队到空队列中，第size个元素即为栈顶
    if (obj->s1->size && obj->s2->size == 0) {//s1不为空
        int flag = obj->s1->size - 1;
        for (int i = 0; i < flag; i++) {
            obj->s2->array[obj->s2->rear] = obj->s1->array[obj->s1->front];
            obj->s2->rear = (obj->s2->rear + 1) % MaxSize;
            obj->s2->size++;
            obj->s1->front = (obj->s1->front + 1) % MaxSize;
            obj->s1->size--;
        }
        temp = obj->s1->array[obj->s1->front];//保存栈顶元素（队尾元素）
        obj->s1->front = (obj->s1->front + 1) % MaxSize;//出栈
        obj->s1->size--;
    }
    else {//s2不为空
        int flag = obj->s2->size - 1;
        for (int i = 0; i < flag; i++) {
            obj->s1->array[obj->s1->rear] = obj->s2->array[obj->s2->front];
            obj->s1->rear = (obj->s1->rear + 1) % MaxSize;
            obj->s1->size++;
            obj->s2->front = (obj->s2->front + 1) % MaxSize;
            obj->s2->size--;
        }
        temp = obj->s2->array[obj->s2->front];//保存栈顶元素（队尾元素）
        obj->s2->front = (obj->s2->front + 1) % MaxSize;//出栈
        obj->s2->size--;
    }
    return temp;//返回栈顶元素
}

int myStackTop(MyStack* obj) {//获取栈顶元素
    assert(obj);
    if (myStackEmpty(obj)) {//栈判空
        return -1;
    }
    if (obj->s1->size && obj->s2->size == 0) {//s1不为空，s2为空
        return obj->s1->array[(obj->s1->rear - 1 + MaxSize) % MaxSize];//直接返回队尾元素即栈顶元素
    }
    else {
        return obj->s2->array[(obj->s2->rear - 1 + MaxSize) % MaxSize];
    }
}

bool myStackEmpty(MyStack* obj) {//栈判空
    if (obj->s1->size == 0 && obj->s2->size == 0) {//两个队列都为空，即栈为空
        return true;
    }
    return false;
}

int StackSize(MyStack* obj) {//获取栈内有效元素个数
    assert(obj);
    return obj->s1->size > obj->s2->size ? obj->s1->size : obj->s2->size;
}

void myStackFree(MyStack* obj) {//栈销毁
    assert(obj);
    if (obj) {
        free(obj->s1->array);
        free(obj->s1);
        free(obj->s2->array);
        free(obj->s2);
        free(obj);
    }
}

Hey小孩
关注
  • 11
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
（剑指offer）面试题09. 用两个栈实现队列
12-21
题目 用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 ) 思路 根据栈的特性，可知inputstack的底部是最新进入的元素，顶部是最先进入的元素。 outputstack用于保存队列头部元素，当为空时，通过outputstack.push(inputstack.pop());来翻转队列，使得inputstack的底部是最先进入的元素，顶部是最新进入的元素。 代码 class CQueue { Stack in
JS实现利用两个队列表示一个栈的方法
11-27
本文实例讲述了JS实现利用两个队列表示一个栈的方法。分享给大家供大家参考，具体如下： 先看原理图： 理清楚思路，再动笔写： <!DOCTYPE html> <html> <head> <title>2 Queue</title> <meta charset="utf-8"/> [removed] var arr1 = []; var arr2 = []; function Queue(arr){ this.push = function(element){ return arr.push(e
面试题：使用两个栈来实现一个队列，完成队列的Push和Pop操作
热门推荐
dangzhangjing97的博客
08-07 4万+
栈的特性：先进后出 队列的特性：先进先出 解析：使用两个栈来实现一个队列，其实就是组合两个栈，来实现队列，栈是先进后出，队列是先进先出，可使用以下操作使用栈来实现队列： 入队列： 1、把需要存放的元素插入到栈1中 出队列： 1、把栈1中的元素依次插入到栈2中 ps：此时栈顶元素就是需要出队列的元素...
用两个队列实现一个栈
蜗牛，为梦想而生。
09-29 1119
void initQueue(Queue **Q) { if(Q==NULL) { return; } *Q=(Queue *)malloc(sizeof(Queue)); if((*Q)==NULL) { return; } (*Q)->front=(*Q)->rear=(QNode *)malloc(sizeof(QNode)); }
使用两个队列实现栈
学饱了
11-22 370
栈的特点是先进后出，队列的特点是先进先出，这里我将用两个队列实现一个栈。
教你如何用两个队列实现一个栈
qq_45691220的博客
04-23 5696
一,实现方法 1.具体思路: 1.准备两个队列AB 2.A用来执行入队列(每次入队列时只要放入A即可) 3.出栈操作时,在A中元素保留一个的情况下将A中元素依次入队列B,最后直接让A中的剩下的那一个元素出队列即可,执行完,交换AB队列(方便下次出栈) 4,取栈顶元素操作时,和出栈操作一样,不过访问完A的唯一元素后,再存放到B(保持数据的完整性),最后交换AB即可 2,图示 二,代码实现 pu...
两个队列实现一个栈
高老板爱吃橙子和橙子的博客
05-15 2800
两个栈实现一个队列1.主要思想2.结构设计3.基本操作（1）初始化（2）入栈（3）获取栈顶第一个元素的值，但不删除（4）获取栈顶第一个元素的值并删除（5）判空（6）判满（7）获取队列有效元素个数（8）清空（9）销毁4.完整代码 1.主要思想 栈的特点：先进后出。队列的特点：先进先出。 我们在用两个队列实现栈的时候是用顺序队列。 2.结构设计 既然是用两个队列实现栈的操作，所以定义的结构体中的成员就是两个队列。 typedef struct { SqQueue q1; SqQueue q2; }TQSt
[数据结构] 用两个队列实现栈详解
weixin_67596609的博客
03-25 2408
​我们上篇文章讲述了用两个栈实现队列，用过对上篇文章的学习后，我们再去学用两个队列实现栈就变得相对来说容易了很多。本篇文章会对用两个队列实现栈进行详解，希望会对你有所帮助。
【使用两个队列实现栈】
邓富民的博客
02-28 2190
使用两个队列实现栈的操作
用两个栈实现一个队列的功能
08-19
//用两个栈实现一个队列的功能 //栈s1提供入队列的功能，栈s2提供出队列的功能 //入队列：如s1 //出队列：(1)如果s2不为空，则直接弹出栈s2的数据(2)如果栈s2为空，则依次弹出栈s1的数据，放入s2中，再弹出栈s2的...
栈实现算术表达式求值和队列实现舞伴配对
05-25
2.设计并实现算法，利用队列模拟课件中案例 3.4 的舞伴配对问题。 问题描述如下： 假设在周末舞会上，男士们和女士们进入舞厅时，各自排成一队。跳舞开始时，依次从 男队和女队的队头上各出一人配成舞伴。若两队...
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
数据结构（七）---二叉树
最新发布
weixin_69884785的博客
04-20 735
一.树的基本概念 二.树的性质 三.二叉树 1.二叉树的基本概念 2.特殊的二叉树 （1）满二叉树 （2）完全二叉树 （3）二叉排序树 （4）平衡二叉树 3.二叉树的性质 4.完全二叉树的性质 5.二叉树的存储结构 （1）顺序存储 （2）链式存储 6.二叉树的遍历 7.二叉树的层序遍历 8.由遍历序列构造二叉树 考法1：前序+中序遍历序列 考法2：后序+中序遍历序列 考法3：层序+中序遍历序列 9.线索二叉树 （1）线索二叉树的作用 （2）线索二叉树的存储结构 线索二叉树的定义： 中序线索化： 先序线索化
数据结构-栈和队列刷题集(长期更新)
2301_81486828的博客
04-17 451
逆波兰表达式又叫做后缀表达式,因为计算机是好辨认出中缀表达式的计算顺序的,所以有时候要用后缀表达式进行求解。2.如果是操作符,弹出两个数字分别作为右操作数跟左操作数运算,结果入栈。3.最后弹出栈内的最后一个元素。1.如果是数字,直接入栈。
数据结构：单链表
2302_78381559的博客
04-16 1632
链表是一种基本的数据结构，它用于存储一系列元素（节点），每个节点不仅包含数据元素，还包含一个指向下一个节点的指针。在链表中，数据并非连续地存储在内存中，而是通过每个节点的指针链接起来形成一个逻辑上的线性序列通过前面我们学习的顺序表我们现在延伸一个链表我们会发现顺序表的一些缺点。
数据结构之顺序表
qq_74336191的博客
04-20 1043
线性表的顺序存储又称为顺序表，顺序表是用一段地址连续的存储单元来依次存储数据元素的线性结构，从而使得逻辑上相邻的两个元素在物理位置上也相邻，也就是说我们可以通过下标来依次访问结构中的内容。平时我们使用的数组也是顺序表的一种实现方式。
学习笔记-数据结构-线性表（2024-04-18）- 单向链表选择排序
XuJiaKai的博客
04-20 422
正经的单向链表选择排序！！不是别人的那种交换值的！
两个栈模拟实现队列c++
10-12
可以使用两个栈来模拟实现队列，一个栈作为输入栈，一个栈作为输出栈。具体实现如下： ```c++ class MyQueue { private: stack<int> inStack; stack<int> outStack; public: MyQueue() {} void push(int x) {...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Hey小孩

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值