代码随想录算法训练营第10天| 理论基础 、 232.用栈实现队列 、 225. 用队列实现栈

顺序：
1.先自己敲代码发现不会
2.看思路题解，不要看具体代码
3.再敲，看能不能通过，找问题
4.发现还是不想，对比看具体代码

理论基础

我想栈和队列的原理大家应该很熟悉了，队列是先进先出，栈是先进后出

首先大家要知道 栈和队列是STL（C++标准库）里面的两个数据结构。

栈先进后出，如图所示：

232.用栈实现队列

题目链接/文章讲解/视频讲解：https://programmercarl.com/0232.%E7%94%A8%E6%A0%88%E5%AE%9E%E7%8E%B0%E9%98%9F%E5%88%97.html

想法

该复习数据结构了

解法

typedef struct 
{
    int top;//头指针，即栈中最先出栈的元素
    int dummyTop;//中转栈的头指针
    int stack[1001];//栈
    int dunmyStack[1001];
} MyQueue;//一个用来中转的栈和一个真正的栈组合起来，变成一个队列


MyQueue* myQueueCreate() 
{
    MyQueue* myQueue = (MyQueue*)malloc(sizeof(MyQueue));//给队列分配空间
    myQueue->top        = -1;//初始化中转栈和栈的头指针
    myQueue->dummyTop   = -1;
    return myQueue;
}

void myQueuePush(MyQueue* obj, int x) //与解法二不同的是，解法一如果栈中无元素，就将新元素直接放入栈中，这样栈其实和队列没有区别，如果栈中有元素，就将栈中元素全部放入中转栈，即将栈中元素顺序颠倒，然后将新元素压入栈，最后将中转栈元素全部放入栈中，即将新元素放在最前面，在栈中最后输出，以用栈结构形成队列操作的结果
{
    if (obj->top == -1)
    {
        obj->stack[++obj->top] = x;
    }
    else
    {
        obj->dummyTop = -1;
        while (obj->top != -1)
        {
            obj->dunmyStack[++obj->dummyTop] = obj->stack[obj->top--];
        }
        obj->stack[++obj->top] = x;
        while (obj->dummyTop != -1)
        {
            obj->stack[++obj->top] = obj->dunmyStack[obj->dummyTop--];
        }
    }
}

int myQueuePop(MyQueue* obj) //由myqueuepush输入到栈中的元素，其实是最后面的元素最先输入
{
    int value = obj->stack[obj->top--];
    return value;
}

int myQueuePeek(MyQueue* obj) 
{
    int value = obj->stack[obj->top];
    return value;
}

bool myQueueEmpty(MyQueue* obj) 
{
    if (obj->top == -1)
        return true;
    return false;
}

void myQueueFree(MyQueue* obj) //直接释放obj指针
{
    free(obj);
}

class MyQueue {
public:
    stack<int> stIn;
    stack<int> stOut;
    /** Initialize your data structure here. */
    MyQueue() {

    }
    /** Push element x to the back of queue. */
    void push(int x) {//正常栈push，队列操作用中转栈实现
        stIn.push(x);
    }

    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        // 只有当stOut为空的时候，再从stIn里导入数据（导入stIn全部数据）
        if (stOut.empty()) {//只有在中转栈为空的前提下，才需要将栈中所有元素放入中转栈中，使栈中元素顺序颠倒，然后以中转栈的栈操作输出，模仿队列操作
            // 从stIn导入数据直到stIn为空
            while(!stIn.empty()) {
                stOut.push(stIn.top());
                stIn.pop();
            }
        }
        int result = stOut.top();//如果中转栈不为空，那么直接可以输出中转栈中的元素，以模仿队列操作
        stOut.pop();
        return result;
    }

    /** Get the front element. */
    int peek() {//复用pop函数
        int res = this->pop(); // 直接使用已有的pop函数
        stOut.push(res); // 因为pop函数弹出了元素res，所以再添加回去
        return res;
    }

    /** Returns whether the queue is empty. */
    bool empty() {
        return stIn.empty() && stOut.empty();
    }
};

下面是我看了题解后写的

typedef struct {
    int top;
    int faketop;
    int stack[1001];
    int fakestack[1001];
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue *myQueue=(MyQueue*)malloc(sizeof(MyQueue));
    myQueue->top=-1;
    myQueue->faketop=-1;    
    return myQueue;
}

void myQueuePush(MyQueue* obj, int x) {
    obj->stack[++obj->top]=x;
}

int myQueuePop(MyQueue* obj) {
    if(obj->faketop==-1){
    while(obj->top!=-1){
    obj->fakestack[++obj->faketop]=obj->stack[obj->top--];
    }}
    return obj->fakestack[obj->faketop--];
}

int myQueuePeek(MyQueue* obj) {
       if(obj->faketop==-1){
    while(obj->top!=-1){
    obj->fakestack[++obj->faketop]=obj->stack[obj->top--];
    }}
    return obj->fakestack[obj->faketop];
}



bool myQueueEmpty(MyQueue* obj) {
    if(obj->top==-1&&obj->faketop==-1)
        return true;
    else 
        return false;
}

void myQueueFree(MyQueue* obj) {
    free(obj);
}

在push数据的时候，只要数据放进输入栈就好，但在pop的时候，操作就复杂一些，输出栈如果为空，就把进栈数据全部导入进来（注意是全部导入），再从出栈弹出数据，如果输出栈不为空，则直接从出栈弹出数据就可以了。

最后如何判断队列为空呢？如果进栈和出栈都为空的话，说明模拟的队列为空了。

在代码实现的时候，会发现pop() 和 peek()两个函数功能类似，代码实现上也是类似的，可以思考一下如何把代码抽象一下。

可以看出peek()的实现，直接复用了pop()， 要不然，对stOut判空的逻辑又要重写一遍。

再多说一些代码开发上的习惯问题，在工业级别代码开发中，最忌讳的就是 实现一个类似的函数，直接把代码粘过来改一改就完事了。

这样的项目代码会越来越乱，一定要懂得复用，功能相近的函数要抽象出来，不要大量的复制粘贴，很容易出问题！（踩过坑的人自然懂）

工作中如果发现某一个功能自己要经常用，同事们可能也会用到，自己就花点时间把这个功能抽象成一个好用的函数或者工具类，不仅自己方便，也方便了同事们。

同事们就会逐渐认可你的工作态度和工作能力，自己的口碑都是这么一点一点积累起来的！在同事圈里口碑起来了之后，你就发现自己走上了一个正循环，以后的升职加薪才少不了你！

225. 用队列实现栈

题目链接/文章讲解/视频讲解：https://programmercarl.com/0225.%E7%94%A8%E9%98%9F%E5%88%97%E5%AE%9E%E7%8E%B0%E6%A0%88.html

想法

将一个队列的前面弹出，只剩最后一个元素后，将其返回

解法

  /** Push element x onto stack. */
    void push(int x) {
        queue2.push(x);
        while (!queue1.empty()) {
            queue2.push(queue1.front());
            queue1.pop();
        }
        swap(queue1, queue2);
    }
    
    /** Removes the element on top of the stack and returns that element. */
    int pop() {
        int r = queue1.front();
        queue1.pop();
        return r;
    }
    
    /** Get the top element. */
    int top() {
        int r = queue1.front();
        return r;
    }
    
    /** Returns whether the stack is empty. */
    bool empty() {
        return queue1.empty();
    }
};

class MyStack {
public:
    queue<int> q;

    /** Initialize your data structure here. */
    MyStack() {

    }

    /** Push element x onto stack. */
    void push(int x) {
        int n = q.size();
        q.push(x);
        for (int i = 0; i < n; i++) {
            q.push(q.front());
            q.pop();
        }
    }
    
    /** Removes the element on top of the stack and returns that element. */
    int pop() {
        int r = q.front();
        q.pop();
        return r;
    }
    
    /** Get the top element. */
    int top() {
        int r = q.front();
        return r;
    }
    
    /** Returns whether the stack is empty. */
    bool empty() {
        return q.empty();
    }
};