两个队列实现为一个栈

#include <queue>  

#include <iostream>  

using namespace std; 

template < typename T> 

class Stack_by_queue 

{ 

     public : 

         Stack_by_queue(){}; 

         ~Stack_by_queue(){}; 

         void append_tail( const T& node); 

         T delete_head(); 

         void Show_Stack( void ); 

     protected : 

     private : 

         queue<T> queue1; 

         queue<T> queue2; 

}; 

template < typename T> 

void Stack_by_queue<T>::Show_Stack( void ) 

{ 

     queue<T> Q1(queue1); 

     queue<T> Q2(queue2); 

     T tmp; 

     cout<< "\n this is Show_Stack!从栈顶到栈底显示数据\n" ; 

     while (!Q1.empty() || !Q2.empty()) 

     { 

            if (Q1.empty() && !Q2.empty()) 

         { 

             //2->1  

             if (Q2.size() < 1) 

             { 

                 return ; 

             } 

             while (Q2.size() != 1) 

             { 

                 tmp = Q2.front(); 

                 Q2.pop(); 

                 Q1.push(tmp); 

             } 

             cout<<Q2.front()<< "  " ; 

             Q2.pop(); 

         } 

         if (!Q1.empty() && Q2.empty()) 

         { 

             //1->2  

             if (Q1.size() < 1) 

             { 

                 return ; 

             } 

             while (Q1.size() != 1) 

             { 

                 tmp = Q1.front(); 

                 Q1.pop(); 

                 Q2.push(tmp); 

             } 

             cout<<Q1.front()<< "  " ; 

             Q1.pop(); 

   

         } 

     } 

   

} 

//保证在所有的过程中，至少队列有一个是空的  

template < typename T> 

T Stack_by_queue<T>::delete_head() 

{ 

     T tmp; 

     if (queue1.empty() && !queue2.empty()) 

     { 

         //2->1  

         if (queue2.size() < 1) 

         { 

         return -1; 

         } 

         while (queue2.size() != 1) 

         { 

             tmp = queue2.front(); 

             queue2.pop(); 

             queue1.push(tmp); 

         } 

         tmp = queue2.front(); 

         queue2.pop(); 

         return tmp; 

     } 

     if (!queue1.empty() && queue2.empty()) 

     { 

         //1->2  

         T tmp; 

         if (queue1.size() < 1) 

         { 

             return -1; 

         } 

         while (queue1.size() != 1) 

         { 

             tmp = queue1.front(); 

             queue1.pop(); 

             queue2.push(tmp); 

         } 

         tmp = queue1.front(); 

         queue1.pop(); 

         return tmp; 

     } 

     else 

         return -1; 

} 

template < typename T> 

void Stack_by_queue<T>::append_tail( const T& node ) 

{ 

     //保证有一队列为空，若全为空，则队空,任选一个队列就行  

     if (queue1.empty() && !queue2.empty()) 

         queue2.push(node); 

     if (!queue1.empty() && queue2.empty()) 

         queue1.push(node); 

     if (queue1.empty() && queue2.empty()) 

         queue1.push(node); 

     else 

         return ; 

} 

int main() 

{ 

     Stack_by_queue< char > my_stack; 

     my_stack.append_tail( 'a' ); 

     my_stack.append_tail( 'b' ); 

     my_stack.append_tail( 'c' ); 

     my_stack.Show_Stack(); 

   

   

     my_stack.delete_head(); 

     my_stack.delete_head(); 

     my_stack.Show_Stack(); 

   

     my_stack.append_tail( 'd' ); 

     my_stack.append_tail( 'e' ); 

     my_stack.Show_Stack(); 

   

     my_stack.delete_head(); 

     my_stack.Show_Stack(); 

   

     my_stack.append_tail( 'f' ); 

     my_stack.Show_Stack(); 

} 

/**************************

运行结果：

  

  this is Show_Stack!从栈顶到栈底显示数据

c  b  a

  this is Show_Stack!从栈顶到栈底显示数据

a

  this is Show_Stack!从栈顶到栈底显示数据

e  d  a

  this is Show_Stack!从栈顶到栈底显示数据

d  a

  this is Show_Stack!从栈顶到栈底显示数据

f  d  a

  

  

***************************/ 

 

#include <queue>

#include <iostream>

using namespace std;

template < typename T>

class Stack_by_queue

{

     public :

         Stack_by_queue(){};

         ~Stack_by_queue(){};

         void append_tail( const T& node);

         T delete_head();

         void Show_Stack( void );

     protected :

     private :

         queue<T> queue1;

         queue<T> queue2;

};

template < typename T>

void Stack_by_queue<T>::Show_Stack( void )

{

     queue<T> Q1(queue1);

     queue<T> Q2(queue2);

     T tmp;

     cout<< "\n this is Show_Stack!从栈顶到栈底显示数据\n" ;

     while (!Q1.empty() || !Q2.empty())

     {

            if (Q1.empty() && !Q2.empty())

         {

             //2->1

             if (Q2.size() < 1)

             {

                 return ;

             }

             while (Q2.size() != 1)

             {

                 tmp = Q2.front();

                 Q2.pop();

                 Q1.push(tmp);

             }

             cout<<Q2.front()<< "  " ;

             Q2.pop();

         }

         if (!Q1.empty() && Q2.empty())

         {

             //1->2

             if (Q1.size() < 1)

             {

                 return ;

             }

             while (Q1.size() != 1)

             {

                 tmp = Q1.front();

                 Q1.pop();

                 Q2.push(tmp);

             }

             cout<<Q1.front()<< "  " ;

             Q1.pop();

 

         }

     }

 

}

//保证在所有的过程中，至少队列有一个是空的

template < typename T>

T Stack_by_queue<T>::delete_head()

{

     T tmp;

     if (queue1.empty() && !queue2.empty())

     {

         //2->1

         if (queue2.size() < 1)

         {

         return -1;

         }

         while (queue2.size() != 1)

         {

             tmp = queue2.front();

             queue2.pop();

             queue1.push(tmp);

         }

         tmp = queue2.front();

         queue2.pop();

         return tmp;

     }

     if (!queue1.empty() && queue2.empty())

     {

         //1->2

         T tmp;

         if (queue1.size() < 1)

         {

             return -1;

         }

         while (queue1.size() != 1)

         {

             tmp = queue1.front();

             queue1.pop();

             queue2.push(tmp);

         }

         tmp = queue1.front();

         queue1.pop();

         return tmp;

     }

     else

         return -1;

}

template < typename T>

void Stack_by_queue<T>::append_tail( const T& node )

{

     //保证有一队列为空，若全为空，则队空,任选一个队列就行

     if (queue1.empty() && !queue2.empty())

         queue2.push(node);

     if (!queue1.empty() && queue2.empty())

         queue1.push(node);

     if (queue1.empty() && queue2.empty())

         queue1.push(node);

     else

         return ;

}

int main()

{

     Stack_by_queue< char > my_stack;

     my_stack.append_tail( 'a' );

     my_stack.append_tail( 'b' );

     my_stack.append_tail( 'c' );

     my_stack.Show_Stack();

 

 

     my_stack.delete_head();

     my_stack.delete_head();

     my_stack.Show_Stack();

 

     my_stack.append_tail( 'd' );

     my_stack.append_tail( 'e' );

     my_stack.Show_Stack();

 

     my_stack.delete_head();

     my_stack.Show_Stack();

 

     my_stack.append_tail( 'f' );

     my_stack.Show_Stack();

}

/**************************

运行结果：

 

  this is Show_Stack!从栈顶到栈底显示数据

c  b  a

  this is Show_Stack!从栈顶到栈底显示数据

a

  this is Show_Stack!从栈顶到栈底显示数据

e  d  a

  this is Show_Stack!从栈顶到栈底显示数据

d  a

  this is Show_Stack!从栈顶到栈底显示数据

f  d  a

 

 

***************************/