栈和队列面试题

1.使用两个栈，实现一个队列。
栈：先进后出，且只能从栈顶pop出数据。
队列：先进先出，对头pop数据，队尾push数据。

代码如下：

#include<stack>

template<typename T>
class MyQueue
{
public:
    void Push(const &data)
    {
        //stack1作为队尾
        stack1.push(data);
    }
    void Pop()
    {
        if (!stack2.empty())
        {
            //如果stack2不为空，stack2的栈顶元素就是队头元素
            stack2.pop();
        }
        else
        {
            while (!stack1.empty())
            {
                T &tmp = stack1.top();
                stack2.push(tmp);
                stack1.pop();
            }
            if (!stack2.empty())
            {
                stack2.pop();
            }
        }
    }

private:
    stack<T> stack1;
    stack<T> stack2;
};

2.两个队列实现一个栈
栈：先进后出，且只能从栈顶pop出数据。
队列：先进先出，对头pop数据，队尾push数据。

#include<queue>
template<class T>
class MyStack {
public:
    void Push(const T &data)
    {
        if (queue1.empty() && queue2.empty())
        {
            queue1.push(data);
        }
        else if (!queue1.empty())
        {
            queue1.push(data);
        }
        else
        {
            queue2.push(data);
        }
    }

    void Pop()
    {
        if (!queue1.empty())
        {
            while (queue1.size() > 1)
            {
                T& data = queue1.front;
                queue2.push(data);
                queue1.pop();
            }
            queue1.pop();
        }
        else if (!queue2.empty())
        {
            while (1)
            {
                T& data = queue2.front();
                queue1.push(data);
                queue2.pop();
            }
            queue2.pop();
        }

    }

private:
    queue<T> queue1;
    queue<T> queue2;
};

---

3.元素入栈出栈的顺序合法性
我们知道栈有这样的性质：后进先出 只能在栈顶入栈和出栈。

代码如下：

#include<vector>
#include<stack>
bool IsPopOrder(vector<int> pushv, vector<int> popv)
{
    if (pushv.size() != popv.size() || pushv.size() <= 0)
        return false;
    stack<int> stackdata;
    int len = pushv.size();
    int indexPopv = 0;
    for (int i = 0; i < len && indexPopv < len; i++)
    {
        stackdata.push(pushv[i]);
        while (stackdata.size() != 0 && stackdata.top() == popv[indexPopv])
        {
            stackdata.pop();
            indexPopv++;
        }
    }

    if (stackdata.empty()&& stackdata.size() == 0)
    {
        return true;
    }
    return false;
}

---

4.一个数组实现两个栈（共享栈）

代码如下：

template<typename T>
class StackArray {
public:
    StackArray()
        :_array(new int[10])
        , _capacity(10)
        ,top1(0)
        ,top2(10)
    {}
    //压栈（压栈如果两个栈顶指针相遇，可以考虑扩容）
    void Stack1Push(const T& data)
    {
        _array[top1] = data;
        top1++;
    }

    void Stack2Push(const T& data)
    {
        _array[top2] = data;
        top2++;
    }

    //出栈
    void Stack1Pop()
    {
        if (top1 > 0)
            top1--;
        else
            cout << "栈已为空！" << endl;
    }

    void Stack2Pop()
    {
        if (top2 < _capacity)
            top1++;
        else
            cout << "栈已为空！" << endl;
    }

    //获取栈顶元素
    T& Stack1Top()
    {
        if (Stack1Empty())
            return _array[top1];
    }

    T& Stack2Top()
    {
        if(Stack2Empty())
            return _array[top2];
    }

    //栈是否为空
    bool Stack1Empty()
    {
        if (top1 == 0)
            return true;
        else
            return false;
    }

    bool Stack2Empty()
    {
        if (top2 == _capacity)
            return true;
        else
            return false;
    }
    ~StackArray()
    {
        if (NULL != _array)
        {
            delete[] _array;
            _capacity = 0;
        }
    }

private:
    T * _array;
    int _capacity;
    int top1;//Stack1 栈顶位置
    int top2;//Stack2 栈顶位置
};