用栈实现队列

用栈实现队列

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

要点：

• 入队时

• 全部压入IN栈

• 出队时

• OUT不为空时，直接从OUT栈弹出（出队）
• OUT为空时，先把IN栈全部出栈后压入OUT栈，最后弹出OUT栈顶（出队）

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

#include<iostream>

template<typename T, int N>
class ArrayStack
{
private:
    T m_array[N];
    int m_size;   //当前元素个数
    int m_top;    //栈顶元素下标

public:
    ArrayStack()
    {
        m_top = -1;
        m_size = 0;
    }
    ~ArrayStack() = default;

    T top() const
    {
        if ( m_size > 0 )
        {
            return m_array[m_top];
        }
        else
        {
            throw std::out_of_range("no element in stack ...");
        }
    }

    void pop()
    {
        if ( m_size > 0)
        {
            m_top--;
            m_size--;
        }
    }

    void push(const T& e)
    {
        if( m_size < N )
        {
            m_array[m_top + 1] = e;//为了异常安全,泛指类型T重载可能抛出异常
            m_top++;//为了异常安全,赋值成功后再做++,保证栈状态正常
            m_size++;
        }
    }

    void clear()
    {
        m_top = -1;
        m_size = 0;
    }

    int capacity() const
    {
        return N;
    }

    int size() const
    {
        return m_size;
    }
};

template<typename T, int N>
class ArrayStack2Queue
{
private:
    mutable ArrayStack<T, N> m_stack_in;
    mutable ArrayStack<T, N> m_stack_out;

    //出栈时元素从in转移到out
    void move() const
    {
        if( m_stack_out.size() == 0 )
        {
            while ( m_stack_in.size() > 0 )
            {
                m_stack_out.push( m_stack_in.top() );
                m_stack_in.pop();
            }
        }
    }

public:
    ArrayStack2Queue() = default;
    ~ArrayStack2Queue() = default;

    void enqueue(const T& e)
    {
        m_stack_in.push(e);
    }

    T front() const
    {
        move();

        if ( m_stack_out.size() > 0 )
        {
            return m_stack_out.top();
        }
        else
        {
            throw std::out_of_range("no element in stack2queue ...");
        }
    }

    void dequeue()
    {
        move();

        if ( m_stack_out.size() > 0 )
        {
            m_stack_out.pop();
        }
    }

    void clear()
    {
        m_stack_in.clear();
        m_stack_out.clear();
    }

    int length() const
    {
        return m_stack_out.size() + m_stack_in.size();
    }
};

int main()
{
    ArrayStack2Queue<int, 5> array_stack_2_queue;

    for ( int i = 0; i < 5; ++i )
    {
        array_stack_2_queue.enqueue(i);
    }

    for ( int i = 0; i < 5; ++i )
    {
        std::cout << array_stack_2_queue.front() << " ";
        array_stack_2_queue.dequeue();
    }
    std::cout << std::endl;

    return 0;
}
//运行结果
0 1 2 3 4

参考

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