C++数据结构第38课、两个有趣的问题

问题1：是否可以用栈实现队列？

用栈实现队列等价于用“后进先出”的特性实现“先进先出”的特性！

解决方案：可以用两个栈进行实现

实现思路：准备用两个栈来实现队列：stack_in 和 stack_out

1、当有新元素入队时：将其压入 stack_in；

2、当需要出队时：

— stack_out.size() == 0 时，将 stack_in 中的元素逐一弹出并压入 stack_out，再将 stack_out 的栈顶元素弹出；

— stack_out.size() > 0 时，将 stack_out 的栈顶元素弹出

我们来看看 StackToQueue 的实现：

#include "LinkStack.h"
#include "LinkQueue.h"

template <typename T>
class StackToQueue : public Queue<T>
{
protected:
    mutable LinkStack<T> m_stack_in;
    mutable LinkStack<T> m_stack_out;

public:
    void add(const T& e)
    {
        m_stack_in.push(e);
    }

    void remove()
    {
        if(m_stack_out.size() == 0)
        {
            while(m_stack_in.size() > 0)
            {
                m_stack_out.push(m_stack_in.top());
                m_stack_in.pop();
            }

        }
        if(m_stack_out.size() > 0)
        {
            m_stack_out.pop();
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No element in current queue ...");
        }
    }

    T front()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();
            }

        }
        if(m_stack_out.size() > 0)
        {
            return m_stack_out.top();
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No element in current queue ...");
        }
    }

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

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

main.cpp

#include <iostream>
#include "LinkStack.h"
#include "LinkQueue.h"

using namespace std;
using namespace XiebsLib;
int main()
{
    StackToQueue<int> sq;

    for(int i=0; i<5; i++)
    {
        sq.add(i);
    }

    while( sq.length() > 0 )
    {
        cout << sq.front() << endl;

        sq.remove();
    }
    return 0;
}

问题2：是否可以用队列实现栈？

其本质为用队列“先进先出”的特性实现“后进先出”的特性！

解决方案：用两个队列实现

实现思路：准备用两个队列用于实现栈：queue_1[in] 和 queue_2[out]。
1、当有新元素入栈时：将其加入队列 [in]；
2、当需要出栈时：
— 将队列 [in] 中的 n-1 个元素出队列，并进入队列 [out] 中
— 将队列 [in] 中的最后一个元素出队列（出栈）
— 交换两个队列的角色：queue_1 [out] 和 queue_2 [in]

我们来看看 QueueToStack 的实现：

template <typename T>
class QueueToStack : public Stack<T>
{
protected:
    LinkQueue<T> m_queue_1;
    LinkQueue<T> m_queue_2;
    LinkQueue<T>* m_pIn;
    LinkQueue<T>* m_pOut;


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

        for(int i = 0; i < n; i++)
        {
            m_pOut->add(m_pIn->front());
            m_pIn->remove();
        }
    }

    void swap()
    {
        LinkQueue<T>* temp = nullptr;

        temp = m_pIn;
        m_pIn = m_pOut;
        m_pOut = temp;
    }
public:
    QueueToStack()
    {
        m_pIn = &m_queue_1;
        m_pOut = &m_queue_2;
    }
    void push(const T& e)
    {
        m_pIn->add(e);
    }
    void pop()
    {
        if(m_pIn->length() > 0)
        {
            move();

            m_pIn->remove();

            swap();
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No element in curruent stack ...");
        }
    }

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

            return m_pIn->front();
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No element in curruent stack ...");
        }
    }

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

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

int main()
{
    QueueToStack<int> qs;

    for(int i=0; i<5; i++)
    {
        qs.push(i);
    }

    while( qs.size() > 0 )
    {
        cout << qs.top() << endl;

        qs.pop();
    }

    return 0;
}