用队列实现栈

用队列实现栈

栈和队列可以相互转换，实现栈需要两个队列：IN 队列 和 OUT 队列。

要点：

• 入栈时：
  • 从 IN 队列入栈
• 出栈时：
  • 将 IN 队列的 n - 1 个元素出队，并依次加入 OUT 队列，此时 IN 队列只剩一个元素，即为栈顶元素
  • 将 IN 队列的最后一个元素出栈（弹出栈顶元素）
  • 将 IN 队列 和 OUT 队列 角色互换

注意：只要访问栈顶元素就要移动元素，只要出栈就要 IN OUT 互换！

出栈示意：

入栈示意：

本节使用C++数组实现队列中实现的队列结构完成栈的实现，只要符合队列特征即可

#include <iostream>

template<typename T, int N>
class ArrayQueue
{
private:
    T m_array[N];
    int m_length;
    int m_head;
    int m_tail;

public:
    ArrayQueue()
    {
        m_length = 0;
        m_head = 0;
        m_tail =0;
    }
    ~ArrayQueue() = default;

    void enqueue(const T& e)
    {
        if ( m_length < N )
        {
            m_array[m_tail] = e;
            m_tail = (m_tail + 1) % N;
            m_length++;
        }
    }

    T front() const
    {
        if ( m_length > 0 )
        {
            return m_array[m_head];
        }
        else
        {
            throw std::out_of_range("no element in queue ...");
        }
    }

    void dequeue()
    {
        if ( m_length > 0 )
        {
            m_head = (m_head + 1) % N;
            m_length--;
        }
    }

    void clear()
    {
        m_head = 0;
        m_tail = 0;
        m_length = 0;
    }

    int capacity() const
    {
        return N;
    }

    int length() const
    {
        return m_length;
    }
};

template<typename T, int N>
class ArrayQueue2Stack
{
private:
    ArrayQueue<T, N> m_queue_1;
    ArrayQueue<T, N> m_queue_2;
    ArrayQueue<T, N>* m_queue_in;
    ArrayQueue<T, N>* m_queue_out;

    void move() const
    {
        int n = m_queue_in->length() - 1;

        for ( int i = 0; i < n; ++i )
        {
            m_queue_out->enqueue( m_queue_in->front() );
            m_queue_in->dequeue();
        }
    }

public:
    ArrayQueue2Stack()
    {
        m_queue_in = &m_queue_1;
        m_queue_out = &m_queue_2;
    }

    void push(const T& e)
    {
        m_queue_in->enqueue(e);
    }

    T top() const
    {
        if ( m_queue_in->length() > 0 )
        {
            move();

            return m_queue_in->front();
        }
        else
        {
            throw std::out_of_range("no element in stack2queue ...");
        }
    }

    void pop()
    {
        if ( m_queue_in->length() > 0 )
        {
            move();

            m_queue_in->dequeue();

            std::swap< ArrayQueue<T, N>* >(m_queue_in, m_queue_out);
        }
    }

    void clear()
    {
        m_queue_1.clear();
        m_queue_2.clear();
    }

    int size() const
    {
        return m_queue_1.length() + m_queue_2.length();
    }
};

int main()
{
    ArrayQueue2Stack<int, 5> m_array_queue_2_stack;

    for ( int i = 1; i <6; ++i )
    {
        m_array_queue_2_stack.push(i);
    }

    for ( int i = 0; i < 5; ++i )
    {
        std::cout << m_array_queue_2_stack.top() << " ";
        m_array_queue_2_stack.pop();
    }
    std::cout << std::endl;
    
    return 0;
}
//运行结果
5 4 3 2 1

参考

• 狄泰软件学院：数据结构实战开发