用兩個隊列實現一個棧

原本畫了圖的，但是今天傳上來的圖片都看不了，只能默默敲下來了

思路：隊列s1和隊列s2

Push進來的元素壓入非空隊列

Pop操做以後的元素放在空隊列

入棧：

（1）s1爲空，s2爲空

  把全部數據壓入s1中

（2）s1爲空，s2不爲空

  數據壓入s2

（3）s1不爲空，s2爲空

  數據壓入s2

出棧：

（1）s2爲空

  把s1中除了隊頭的元素所有壓入s2中，而後彈出s1隊頭中的元素

（2）s1爲空

  把s2中除了隊頭的元素所有壓入s1中，而後彈出s1隊頭中的元素

#include<iostream>

#include<queue>

using namespace std;

template<typename T>

class Stack

{

public:

                Stack()

                { }

                Stack( const Stack & d)

                {

                                s1 = d.s1;

                                s2 = d.s2;

                }

                ~Stack()

                { }

                 void push(const T&x) //在棧頂增長元素

                {

                                 if (s1.size() > 0)    //若是s1不爲空，則把數據插入s1中

                                {

                                                s1.push( x);

                                }

                                 else if (s2.size() > 0)   //若是s2不爲空，則把數據插入s2中

                                {

                                                s2.push( x);

                                }

                                 else        //若是兩個都爲空，則把數據插入s1

                                {

                                                s1.push( x);

                                }

                }

                 void pop() // 移除棧頂元素

                {

                                 if (s1.size() == 0)

                                {

                                                 while (s2.size() != 1)

                                                {

                                                                s1.push(s2.front());

                                                                s2.pop();

                                                }

                                                s2.pop();

                                }

                                 else

                                {

                                                 while (s1.size() != 1)

                                                {

                                                                s2.push(s1.front());

                                                                s1.pop();

                                                }

                                                s1.pop();

                                }              

                }

                 T& top() //返回棧頂元素

                {

                                 if (s1.size() == 0)

                                {

                                                 return s2.front();

                                }

                                 else

                                {

                                                 return s1.front();

                                }

                }

                 bool empty() //堆棧爲空則返回真

                {

                                 if (s1.size() == 0 && s2.size() == 0)

                                {

                                                 return true ;

                                }

                                 else

                                {

                                                 return false ;

                                }

                }

                 size_t size() //返回棧中元素數目

                {

                                 return s1.size() + s2.size();

                }

private:

                 queue<T > s1;

                 queue<T > s2;

};

void Test()

{

                 Stack<int > sta;

                sta.push(1);

                sta.push(2);

                sta.push(3);

                sta.push(4);

                sta.pop();

                sta.pop();

                sta.push(5);

                sta.push(6);

                 //int ret=sta.top();

                 int num=sta.size();

}

int main()

{

                Test();

                 return 0;

}