栈和队列相关面试题2

最新推荐文章于 2025-07-26 21:49:47 发布

原创最新推荐文章于 2025-07-26 21:49:47 发布 · 736 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍如何使用两个栈实现队列的功能，以及利用两个队列实现栈的操作。通过具体的算法步骤和代码示例，展示了不同数据结构之间的转换方法。

题目：（1）使用两个栈实现一个队列

（2）使用两个队列实现一个栈

使用两个栈实现一个队列：

我们知道对于栈，它是先进后出，而对于队列，它是先进先出。所以用两个栈实现一个队列最直观的思路就是：

设这两个栈分别为s1，s2，始终把s1作为存储空间，把s2作为临时空间。那么

（1）入队时把元素压入s1

（2）出队时先把s1中除最底下所有元素都倒入s2，然后弹出s1的唯一元素，再把s2中所有元素倒回s1

可以看出s2是一个辅助空间，这样做每次出队时都要先将元素从s1倒入s2，然后再从s2倒回s1。实际上我们还有

一个做法可以减少这里的"倒"次数，性能比较高，方法如下：

（1）入队时把元素压入s1

（2）出队时出队时，判断s2是否为空，如不为空，则直接弹出s2的栈顶元素，如为空，则把s1的除最

底部元素外的所有元素逐个倒入s2，然后弹出s1的唯一元素

using namespace std;  
const int N = 512;  
  
template<class T>  
class Stack  
{  
    private:  
    T S[N];  
    int size;  
  
    public:  
    void clear();  
    void push(const T&);  
    bool empty();  
    T pop();  
};  
  
template<class T>  
void Stack<T>::clear()  
{  
    size = 0;  
}  
  
template<class T>  
void Stack<T>::push(const T &x)  
{  
    if(size == N) return;  
    S[size++] = x;  
}  
  
template<class T>  
T Stack<T>::pop()  
{  
    if(size == 0) return NULL;  
    return S[--size];  
}  
  
template<class T>  
bool Stack<T>::empty()  
{  
    if(size == 0) return true;  
    return false;  
}  
  
template<class T>  
class Queue  
{  
    private:  
    Stack<T> s1,s2;  
  
    public:  
    void clear();  
    void push(const T&);  
    bool empty();  
    T pop();  
};  
  
template<class T>  
void Queue<T>::clear()  
{  
    s1.clear();  
    s2.clear();  
}  
  
template<class T>  
void Queue<T>::push(const T &x)  
{  
    s1.push(x);  
}  
  
template<class T>  
T Queue<T>::pop()  
{  
    if(!s2.empty()) return s2.pop();  
    while(!s1.empty())  
        s2.push(s1.pop());  
    return s2.pop();  
}  
  
template<class T>  
bool Queue<T>::empty()  
{  
    if(s1.empty() && s2.empty()) return true;  
    return false;  
}  
  
int main()  
{  
    Queue<int> Q;  
    Q.clear();  
    for(int i=0;i<50;i++)  
        Q.push(i);  
    while(!Q.empty())  
        cout<<Q.pop()<<" ";  
    cout<<endl;  
    return 0;  
}

两个队列实现一个栈：

队列是先进先出，而栈是先进后出；

考虑到我们取栈顶元素的便利性，我们在实现时使得栈顶等于队列头；

由于栈的pop弹出栈顶元素，而队列的pop也是弹出栈顶元素，所以我们需要特别处理的是插入操作。

由于往栈中添加元素相当于往队列头添加元素，因此我们需要在两个队列中进行元素的转移，比较简单的实现是：

1.q1和q2在任一时刻至少有一个为空，即如果有元素，所以元素只在同一个队列中。
2.当有元素需要插入时，将插入的元素插入到空的队列中，并将另一非空队列的元素转移到该队列中，于是插入的元素添加到了队列头中。

class Stack {
public:
    // Push element x onto stack.
    void push(int x) {
        if (!q1.empty())
        {
            q2.push(x);
            while (!q1.empty())
            {
                q2.push(q1.front());
                q1.pop();
            }
        }
        else
        {
            q1.push(x);
            while (!q2.empty())
            {
                q1.push(q2.front());
                q2.pop();
            }
        }
    }

    // Removes the element on top of the stack.
    void pop() {
        if (q1.empty()&&q2.empty())
            throw new exception("stack is empty");
        else if (!q1.empty()) q1.pop();
        else q2.pop();
    }

    // Get the top element.
    int top() {
        if (!q1.empty()) return q1.front();
        else return q2.front();
    }

    // Return whether the stack is empty.
    bool empty() {
        return (q1.empty()&&q2.empty());
    }

private:
    queue<int> q1, q2;
};