栈和队列面试题1【菜鸟学习日记】

开篇点题，今天做了几道栈和队列的题，
在此，记录分享

1、实现一个栈，要求这个栈实现Push（出栈）、Pop(入栈）、Min（返回最小值的操作的时间复杂度为O（1））

来分析一下，
思路1：我们可以底层用两个栈来实现
先建个类，写个框架，实现3个接口

class MinSt{public:    void Push(const int& x)    {...}    void Pop()    {...}    int Min()    {...}protected:    stack<int> _st;    stack<int> _minst;};

然后我们再来分析一下如何写，分析一下过程

虽然我们底层是用两个栈实现的，但外面看起来要像一个栈，那么我们这两个栈要保持一致，同进同出

这里进栈出栈时，_st栈不用特殊考虑，但_minst我们是用它记录最小值的所以要特殊考虑

我们可以从上图看到，_minst入栈的要求是比当前栈顶的数小或者等于才能入栈，否则将当前栈顶再入栈

void Push(const int& x)    {        _st.push(x);        if (_minst.size() == 0||x<_minst.top())        {            _minst.push(x);        }        else        {            _minst.push(_minst.top());        }    }

此时我们_minst的栈顶永远是最小值

出栈时，只要考虑不为空即可

void Pop()    {        if (!_st.empty() && !_minst.empty())        {            _st.pop();            _minst.pop();        }    }

返回最小值就Pop出_minst栈顶

    int Min()    {        if (!_minst.empty())        {            return _minst.top();        }    }

测试一下

void test1(){    MinSt s;    s.Push(5);    s.Push(3);    s.Push(6);    s.Push(1);    s.Push(2);    s.Pop();    s.Pop();    cout << s.Min() << endl;}

这个写法还可以优化，_minst中重复入栈3，我们还可以用其他方法优化，后面再补充

---

2、用两个栈实现一个队列

我们先来画图分析一下

class TwoStackOneQueue{public:      ...private:    stack<int> PushStack;    stack<int> PopStack;};

先创建两个栈，一个用来入，一个用来出

我们大概先说一下思路

入栈1，2，3

当要Pop时，将1，2，3导入进PopStack，这时的栈顶，就是我们应该要Pop的正确数了

然后我们再入栈时应该入PushStack

首先我们先来实现Push（）接口，这个接口我们不用特别考虑什么，想清楚入栈都入PushStack

void Push(const int&x)    {        //入时永远入PushStack栈        PushStack.push(x);    }

然后就是出栈

我们每次出PopStack即可，如果为空了，就将PushStack倒过去，再出就好

下面是全部代码

class TwoStackOneQueue{public:    void Push(const int&x)    {        //入时永远入PushStack栈        PushStack.push(x);    }    void Pop()    {        if (PopStack.empty())        {            PutPop();        }        PopStack.pop();    }    int& Front()    {        if (PopStack.empty())        {            PutPop();        }        return PopStack.top();    }    bool Empty()    {        return PushStack.empty() && PopStack.empty();    }    size_t Size()    {        return PushStack.size() + PopStack.size();    }private:    void PutPop()    {        while (!PushStack.empty())        {            PopStack.push(PushStack.top());            PushStack.pop();        }    }private:    stack<int> PushStack;    stack<int> PopStack;};void test2(){    TwoStackOneQueue q;    q.Push(1);    q.Push(2);    q.Push(3);    q.Pop();    cout<<q.Front()<<endl;//2    q.Pop();    cout << q.Front() << endl;//3    q.Push(4);    q.Pop();    cout << q.Front() << endl;//4}

---

3、用两个队列实现一个栈

入队列1，2，3，4

可是我们现在要出4，所以我们可以将1，2，3全放到另一个队列中去，就可以出4了

我们如数据的时候都入不为空有数据的那个，这样我们才能就一个在出的时候将前面数据移过去，出队列

要知道哪个空队列，写个函数就好了

还有就是移数据也可以单独写个函数，方便后面调用，并最好都设为私有，外面看不到，这样只能看到那些栈有的接口，更好一些

private:    void PutEmpty()    {        QEmpty();        while (nonemptyq->size() > 1)        {            emptyq->push(nonemptyq->front());            nonemptyq->pop();        }    }    void QEmpty()    {        if (_q2.empty())        {            swap(emptyq, nonemptyq);        }    }

其它的也就没什么了，不说了，上全部代码

class TwoQueueOneStack{public:    void Push(const int&x)    {        //入时入非空的队列        QEmpty();        nonemptyq->push(x);    }    void Pop()    {        PutEmpty();        nonemptyq->pop();    }    int& Top()    {        QEmpty();        return nonemptyq->back();    }    bool Empty()    {        return _q1.empty() && _q2.empty();    }    size_t Size()    {        return _q1.size() + _q2.size();    }private:    void PutEmpty()//移数据    {        QEmpty();        while (nonemptyq->size() > 1)        {            emptyq->push(nonemptyq->front());            nonemptyq->pop();        }    }    void QEmpty()    {        if (_q2.empty())        {            swap(emptyq, nonemptyq);        }    }private:    queue<int> _q1;    queue<int> _q2;    queue<int>* emptyq = &_q1;    queue<int>* nonemptyq = &_q2;};void test3(){    TwoQueueOneStack s;    s.Push(1);    s.Push(2);    s.Push(3);    s.Push(4);    s.Pop();    cout << s.Top()<<endl;//3    s.Push(5);    cout << s.Top() << endl;//5}

以上，今天总结完毕，剩下的以后再写吧！

———-【菜鸟日记】by 小宣子