STL-关于栈和队列的面试题

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

题目不做讲解，仅为代码参考，如有错误欢迎指正！
1.实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最小值的操作）的时间复杂度为O(1)。

template <class T>
class MinStack
{
public:
    void Push(const T& x)
    {
        s1.push(x);
        if (s2.empty() || x <= s2.top())
        {
            s2.push(x);
        }
    }

    void Pop()
    {
        if (s1.top() == s2.top())
        {
            s2.pop();
        }
        s1.pop();
    }

    T& Min()
    {
        if (!s2.empty())
        {
            return s2.top();
        }
    }

protected:
    stack<T> s1;
    stack<T> s2;
};

2.使用两个栈实现一个队列。

template <class T>
class Queue
{
public:
    void Push(const T& x)
    {
        if (s2.empty())
        {
            s1.push(x);
        }
        else
        {
            while (!s2.empty())
            {
                T tmp = s2.top();
                s1.push(tmp);
                s2.pop();
            }
            s1.push(x);
        }
    }

    void Pop()
    {
        if (s2.empty())//将s1的数据全部倒进s2
        {
            while (!s1.empty())
            {
                T tmp = s1.top();
                s2.push(tmp);
                s1.pop();
            }
        }
        T tmp = s2.top();
        s2.pop();
    }

protected:
    stack<T> s1;
    stack<T> s2;
};

3.使用两个队列实现一个栈。

template <class T>
class Stack
{
public:
    void Push(const T& x)
    {
        if (q2.empty())
        {
            q1.push(x);
        }
        else
        {
            while (!q2.empty())
            {
                T tmp = q2.front();
                q1.push(tmp);
                q2.pop();
            }
            q1.push(x);
        }
    }

    void Pop()
    {
        while (q1.size() != 1)
        {
            T tmp = q1.front();
            q2.push(tmp);
            q1.pop();
        }
        q1.pop();
    }

protected:
    queue<T> q1;
    queue<T> q2;
};

4.判断元素出栈、入栈顺序的合法性。如：入栈的序列（1, 2, 3, 4, 5），出栈序列为（4, 5, 3, 2, 1）是合法序列，入栈的序列（1, 2, 3, 4, 5），出栈序列为（1, 5, 3, 2, 4）是不合法序列。

class LegalStack
{
public:
    void Push(const T& x)
    {
        s1.push(x);
    }

    void Pop()
    {
        while (!s2.empty())
        {
            std::cout << s2.top() << " ";
            s2.pop();
        }
        while (!s1.empty())
        {
            std::cout << s1.top() << " ";
            s1.pop();
        }
    }

    void ChangeSort(size_t num = 0)
    {
        assert(num < s1.size());

        while (num--)
        {
            T tmp = s1.top();
            if (!s1.empty())
            {
                s2.push(tmp);
                s1.pop();
            }
        }
    }

protected:
    stack<int> s1;
    stack<int> s2;
};

5.一个数组实现两个栈。

template <class T>
class DoubleStack
{
public:
    DoubleStack()
        :_a(NULL)
        , _top1(0)
        , _top2(0)
        , _capacity(0)
    {}

    void CheckCapacity()
    {
        if (_a == NULL)
        {
            _capacity += 3;
            _a = new T[_capacity];
            _top2 = _capacity - 1;
            return;
        }
        if (_top1 == _top2)
        {
            size_t capacity = _capacity;
            _capacity *= 2;
            T* tmp = new T[_capacity];
            for (size_t i = 0; i < _top1; i++)//把左边的挪下去
            {
                tmp[i] = _a[i];
            }

            for (size_t i = capacity - 1, j = _capacity - 1; i > _top2; i--, j--)//把右边的挪下去
            {
                tmp[j] = _a[i];
            }

            delete[] _a;
            _a = tmp;
            _top2 += _capacity/2;
        }
    }

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

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

    void Pop1()
    {
        _a[_top1--] = T();
    }

    void Pop2()
    {
        _a[_top2++] = T();
    }

    size_t Size1()
    {
        return _top1;
    }

    size_t Size2()
    {
        return _capacity - 1 - _top2;
    }

    T& Top1()
    {
        return _a[_top1-1];
    }

    T& Top2()
    {
        return _a[_top2 + 1];
    }

    void Print()
    {
        cout << "Stack1 is: ";
        for (size_t i = 0; i < _top1; i++)
        {
            cout << _a[i] << " ";
        }
        cout << endl;

        cout << "Stack2 is: ";
        for (size_t i = _capacity-1; i > _top2; i--)
        {
            cout  << _a[i] << " ";
        }
        cout << endl;
    }

protected:
    T* _a;
    size_t _top1;
    size_t _top2;
    size_t _capacity;
};