栈和队列的常见题型

一、常见题型如下：

1. 实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最小值的操作）的时间复杂度为O(1)
2. 使用两个栈实现一个队列
3. 使用两个队列实现一个栈
4. 元素出栈、入栈顺序的合法性。如入栈的序列（1,2,3,4,5），出栈序列为（4,5,3,2,1）
5. 一个数组实现两个栈。

二、解法分析及示例代码

1.第一题最小值栈

前两种操作Push（出栈）、Pop（入栈）比较好实现，也是栈中比较基本的操作，题目没有明确要求所以我们可以直接用STL容器，进行个封装即可，stack中这两个操作的时间复杂度就是O(1)，但是第三个操作Min（返回最小值的操作）的时间复杂度为O(1)，则要我们自己想办法。思路是用两个栈，一个就是普通的存取数据的栈，另一个为当前栈未知的最小值，因为出栈入栈都会使当前栈的最小值发生变化，所以插入数据和删除数据两个栈都要进行操作，返回当前栈最小值的话，就可以直接对第二个栈操作。

★使用两个栈，s1,s2，先将第一个元素同时对s1，s2入栈，然后接着对s1入栈，将s1入栈的元素和s2.top比较，假如s2.top大于入栈元素,则把该元素对s2也入栈（☛s2.top和入栈元素相等时也要入栈S2）；否则将下一个元素对主栈S1入栈，依次进行；
★出栈时，把s1出栈的元素和栈顶（s2.top）比较，相等就是最小值；同时s1，s2出栈，否则s1单独出栈。

 这种方法在出现大量重复的数据情况下辅助栈也会保存大量重复的最小值数据，这时空间利用率较低。这个时候就想到了另一种方案，就是引用计数，将重复的最小值数据用引用计数来实现存储。实现图示如下：

 

代码示例：

template <class T>
class MyStack
{
public:
    void Push(const T& x)  
    {
        _st.push(x);  //数据栈先入栈
        if (min_st.empty())  //如果Min栈之前没有数据，则直接入栈
        {
            min_st.push(make_pair(x, 1);  //x入Min栈，并置计数为1
        }
        else  {
            pair<T, count>& _min = min_st.top();  
            if (x < _min.first)  //如果入数据栈的数据小于Min栈顶数据，则也入MIn栈
            {
                min_st.push(make_pair(x, 1));   //x入Min栈，并置计数为1
            }else if (x == _min.first)  //如果入数据栈的数据等于Min栈顶数据，即出现冗余数据，计数加1
            {
                _min.second++;
            }
        }
    }
    void Pop()
    {
        assert(!_st.empty());
        pair<x, count>& _min = min_st.top();
        if (_st.top() == _min.first)  
        {
            if (--_min.second == 0) //计数为1时，最小值出栈，否则计数减1
            {
                min_st.pop();
            }
        }
        _st.pop();
    }
    T Min()
    {
        return min_st.top();
    }
private:
    stack<T> _st;  //数据栈
    stack<pair<T, count>> min_st;  //最小值栈
};

2.两个栈实现一个队列

思路是：两个栈s1,s2,始终维护s1作为存储空间，以s2作为临时缓冲区。

入队时，将元素压入s1。

出队时，将s1的元素逐个“倒入”（弹出并压入）s2，将s2的顶元素弹出作为出队元素，之后再将s2剩下的元素逐个“倒回”s1。

见下面示意图：

实现代码如下：

template <class T>
class TwoStackQueue
{
public:
    void Push(T k)
    {
        s1.push(k);
    }
    void Pop()
    {
        if (s1.empty() && s2.empty() == false) {
            while (s1.empty())
            {
                s2.push(s1.top());
                s1.pop();
            }
            s2.pop();
            while (s2.empty())
            {
                s1.push(s2.top());
                s2.pop();
            }
        }
    }
private:
    stack<T> s1;
    stack<T> s2;
};

这个题还可以优化一下。即：在出队时，将s1的元素逐个“倒入”s2时，原在s1栈底的元素，不用“倒入”s2（即只“倒”s1.Count()-1个），可直接弹出作为出队元素返回。这样可以减少一次压栈的操作。

上述思路，有些变种，如：

入队时，先判断s1是否为空，如不为空，说明所有元素都在s1，此时将入队元素直接压入s1；如为空，要将s2的元素逐个“倒回”s1，再压入入队元素。

出队时，先判断s2是否为空，如不为空，直接弹出s2的顶元素并出队；如为空，将s1的元素逐个“倒入”s2，把最后一个元素弹出并出队。

相对于第一种方法，变种的s2好像比较“懒”，每次出队后，并不将元素“倒回”s1，如果赶上下次还是出队操作，效率会高一些，但下次如果是入队操作，效率不如第一种方法。我感觉（没做深入研究），入队、出队操作随机分布时，上述两种方法总体上时间复杂度和空间复杂度应该相差无几（无非多个少个判断）。

真正性能较高的，其实是另一个变种。即：

入队时，将元素压入s1。

出队时，判断s2是否为空，如不为空，则直接弹出顶元素；如为空，则将s1的元素逐个“倒入”s2，把最后一个元素弹出并出队。

这个思路，避免了反复“倒”栈，仅在需要时才“倒”一次。

3.两个队列实现一个栈

思路是：q1是专职进出栈的，q2只是个中转站

入栈：直接入队列q1即可

出栈：把q1的除最后一个元素外全部转移到队q2中,然后把刚才剩下q1中的那个元素出队列。之后把q2中的全部元素转移回q1中。

代码示例：

    template<class T>
    class Queue
    {
    public:
        void Push(const T& x)
        {
            _in.push(x);
        }

        void Pop()
        {
            assert(!_in.empty() || !_out.empty());
            
            if (_out.empty())
            {
                while (!_in.empty())
                {
                    _out.push(_in.top());
                    _in.pop();
                }
            }

            _out.pop();
        }

        T& Front()
        {
            assert(!_in.empty() || !_out.empty());

            if (_out.empty())
            {
                while (!_in.empty())
                {
                    _out.push(_in.top());
                    _in.pop();
                }
            }

            return _out.top();
        }
        

    private:
        stack<T> _in;
        stack<T> _out;
    };

思路二：

q1是专职进出栈的，q2只是个中转站。元素集中存放在一个栈中，但不是指定(q1 或 q2)。定义两个指针：pushtmp:指向专门进栈的队列q1； tmp：指向临时作为中转站的另一个栈q2

入栈：直接入pushtmp所指队列即可

出栈：把pushtmp的除最后一个元素外全部转移到队列tmp中,然后把刚才剩下q1中的那个元素出队列

示例代码二：

void Push(Queue *q1, Queue *q2, int k)
{
        Queue *pushtmp;
        if(!IsQueueEmpty(q1))
        {
            pushtmp = q1;
        }
        else
        {
            pushtmp = q2;
        }
        EnQueue(pushtmp, k);
}

int  Pop(Queue *q1, Queue *q2)
{
    int tmpvalue;
    Queue *pushtmp, *tmp;
    if(!IsQueueEmpty(q1))
    {
        pushtmp = q1;
        tmp = q2;
    }
    else
    {
        pushtmp = q2;
        tmp = q1;
    }

    if(IsQueueEmpty(pushtmp))
    {
       printf("Stack Empty!
");
    }
    else
    {
        while(SizeOfQueue(pushtmp) != 1)
        {
            EnQueue(tmp, DeQueue(pushtmp));
        }
        tmpvalue = DeQueue(pushtmp);
        return tmpvalue;
    }
}

比较： 在第二种思路中，出栈后就不用转移回原来的栈了（图示最后一步），这样减少了转移的次数。

4.元素出栈、入栈顺序的合法性

这是比较常见的判断出栈顺序是否合法性的题目，思路是：

1）用一个 st 栈做入栈序列（1,2,3,4,5）出入栈操作，然后定义指针 in 和 out ，in 指向入栈序列，out 指向需要判断的出栈序列;

2)将入栈序列第一个数据入栈，如果此数据与第一个出栈序列数据相等，则再出栈，再比较两个序列的第二个数据；

3）若不相等，入栈序列第二个数据入栈，再与出栈序列比较；

4）若入栈序列遍历完且临时栈已空，而出栈序列没完，则不合法，若出栈序列也遍历完，则合法。

示例代码：

    bool IsInvalidStack(char* in, char* out)
    {
        assert(in && out);

        stack<char> st;
        while (1)
        {
            while (!st.empty())
            {
                if (*out && st.top() == *out)
                {
                    st.pop();
                    ++out;
                }
                else
                {
                    break;
                }
            }
    
            if (*in)
            {
                st.push(*in);
                ++in;
            }
            else
            {
                if (*out)
                {
                    return false;
                }
                else
                {
                    return true;
                }
            }
        }
    }
    void TestIsInvalidStack()
    {
        char* in = "12345";
        char* out = "45321";
        cout<<IsInvalidStack(in, out)<<endl;
    }

5.一个数组实现两个栈

这个题有多种思路解题：

①奇偶位存储：数组的奇数位置存储一个栈的元素，偶数位置存储另一个栈的元素；

示例代码：

template<class T, size_t N>
    class DoubleStack
    {
    public:
        DoubleStack()
            :_top1(-2)
            ,_top2(-1)
        {}

        void Check(int pos)
        {
            if (pos >= _a.size())
            {
                _a.resize(pos*2);
            }
        }

        void Push1(const T& x)
        {
            Check(_top1+2);
            _a[_top1+2] = x;
        }

        void Push2(const T& x)
        {
            _a[_top2+2] = x;
        }

    private:
        vector<T> _a;
        int _top1;
        int _top2;
    };

②左右存储：两个栈分别从数组的中间向两头增长； 数组的中间位置看做两个栈的栈底，压栈时栈顶指针分别向两边移动，当任何一边到达数组的起始位置或是数组尾部，则开始扩容；

实际上方法二与方法一空间利用率相当本质上相同，所以方法二代码就不实现了。

③两端生长：两个栈分别从数组的两头开始增长。 将数组的起始位置看作是第一个栈的栈底，将数组的尾部看作第二个栈的栈底， 压栈时，栈顶指针分别向中间移动，直到两栈顶指针相遇，则扩容；

示例代码：

//两个栈分别从数组的两头开始向中间增长。
template <class T>
class DoubleStack2
{
public:
    void Push(int index, T data)
    {
        if (top1 > top2)  //已满
            return;
        if (index == 0)  {  //对栈1操作
            top1++;
            array[top1] = data;
        }
        else if(index == 1) {  //对栈2操作
            top2--;
            array[top2] = data;
        }
    }
    void Pop(int index)
    {
        if (index == 0) {  //对栈1操作
            if (top1 >= 0)  //栈1不为空时
                top1--;
        }
        else if (index == 1) {  //对栈2操作
            if (top2 < MAX)    //栈2不为空时
                top2++;
        }
    }
    T& top(int index)
    {
        if (index == 0 && top1 > 0) {  //对栈1操作
            return array[top1 - 1];
        }
        if (index ==1 && top2 < MAX) {
            return array[top2 + 1]
        }
    }
private:
    T* array[MAX];
    int top1;
    int top2;
};

 前两种方法在一定的情况下会造成空间的浪费，比如当一个栈存满了而另一个栈还是空的，这时候空间利用率不高，所以建议采用第三种方式完成。当一个栈一直入栈，另一个栈一直出栈时，方法三的空间利用率是比较好的。