两个栈实现一个队列与两个队列实现一个栈

http://blog.csdn.net/z84616995z/article/details/19204529

两个栈实现一个队列：

原理方法：用一个栈为主栈，一个栈为辅助栈存放临时元素。

入队：将元素依次压入主栈

出队：先检测辅助栈是否为空，如果非空，那么直接弹出辅助栈顶元素，相当于出队。如果为空，那么将主栈元素倒入到辅助栈中，然后弹出辅助栈顶元素。达到先进先出的目的。

以下是代码：

[cpp] view plain copy 
 //两个个栈实现一个队列  
 /*#include <iostream>  
 #include <time.h>  
 #include <windows.h>  
 using namespace std;  
 #define MAX 10  
 struct stack  
 {  
     int Array[MAX];  
     int top;  
 };  
 struct stack s1,s2;  
 //初始化一个空栈  
 int Init_Stack()  
 {  
     s1.top=s2.top = -1;//top为-1表示空栈  
     return 1;  
 }  
 //入队  
 void enqueue(int Array[],int x)  
 {  
     if (s1.top==MAX-1)//检测是否栈已满  
     {  
         cout<<"overflow!"<<endl;  
     }   
     else  
     {  
         s1.top++;  
         s1.Array[s1.top]=x;//将元素压入主栈  
     }  
 }  
 //出队  
 int dequeue()  
 {  
     if (s1.top==-1&&s2.top==-1)//如果主栈和辅助栈都是空的，那么就出现下溢。提示错误后返回  
     {  
         cout<<"underflow!"<<endl;  
         return -1;  
     }  
    if (s2.top==-1)//如果辅助栈为空，那么就循环地将主栈元素倒入辅助栈  
    {  
       for (int i=s1.top;i>0;i--)  
       {  
           s1.top--;s2.top++;  
           s2.Array[s2.top]=s1.Array[s1.top+1];  
       }  
       s1.top--;  
       return s1.Array[s1.top+1];//返回主栈最后一个元素作为出队元素  
    }   
    else //如果辅助栈不空，那么直接弹出辅助栈栈顶元素作为出队元素  
    {  
        s2.top--;  
        return s2.Array[s2.top+1];  
    }  
 }  
 void main()  
 {  
     int x=0;  
     Init_Stack();  
     srand( (unsigned)time( NULL ) );  
     cout<<"数组中的数据入队中。。。";  
     for( int j=0; j <= 100; j++ )      // 打印百分比   
     {  
         cout.width(3);  
         cout << j << "%";  
         Sleep(40);  
         cout << "\b\b\b\b";//\b退格符号  
     }  
         cout << "\n\n";  
     cout<<"Array=";  
     for (int i=0;i<MAX;i++)  
     {  
         x=rand()%100;  
         cout<<x<<" ";  
         enqueue(s1.Array,x);  
     }  
     cout<<endl;  
     cout<<"所有数据入队完毕！"<<endl;  
     cout<<endl;  
     cout<<"数组中的数据出队中。。。";  
     for(  j=0; j <= 100; j++ )      // 打印百分比   
     {  
         cout.width(3);  
         cout << j << "%";  
         Sleep(40);  
         cout << "\b\b\b\b";//\b退格符号  
     }  
     cout << "\n\n";  
     cout<<"Array=";  
     for ( i=0;i<MAX;i++)  
     {  
         cout<<dequeue()<<" ";  
     }  
     cout<<endl;  
     cout<<"所有数据出队完毕！"<<endl;  
     cout<<endl;  
     enqueue(s1.Array, 56);  
     cout<<dequeue()<<endl;  
     cout<<dequeue()<<endl;  
     cout<<dequeue()<<endl;  
     enqueue(s1.Array, 65);  
     enqueue(s1.Array, 10);  
     enqueue(s1.Array, 32);  
     cout<<dequeue()<<endl;  
     cout<<dequeue()<<endl;  
     enqueue(s1.Array, 2);  
     cout<<dequeue()<<endl;        
 }  

运行时间为O(n),在进行倒入操作时需要循环倒入，所以时间为n

两个队列实现一个栈：

原理方法：用一个队列为主队列，一个队列为辅助队列存放临时元素。

入栈：将元素依次压入主队列

出栈：先将拥有n个元素的主队列的其中的n-1个元素倒入辅助队列，然后将原主队列的最后剩下的一个元素弹出队列，相当于出栈，这个时候，辅助队列和主队列进行交换，继续进行刚才的出栈操作。

[cpp] view plain copy 
 //两个队列实现一个栈  
 #include <iostream>  
 #include <time.h>  
 #include <windows.h>  
 using namespace std;  
 #define MAX 10   
 struct queue  
 {  
     int head;//声明队头指针  
     int tail;//声明队尾指针  
     int length;//声明队列当前含有的元素个数  
     int Array[MAX];//声明数组所能容纳的最大元素个数  
 };  
 struct queue q1,q2; //声明两个队列结构体全局变量  
 void Init_queue(struct queue &q1)//初始化队列  
 {  
     q1.head=q1.tail=1;//队列初始时是从数组Array[1]开始的，所以其实Array[0]是数组最后一个元素，而不是Array[MAX-1]！这是需要注意的。  
     q1.length=1;  
 }  
 //入栈  
 int push(int Array[],int x)  
 {  
    if (q1.head==q1.tail+1)//进行入队操作的前提判断是否队列已满  
    {  
        cerr<<"overflow!"<<endl;//若已满，那么提示错误后返回。  
        return -1;  
    }  
    else  
    {  
        if (q1.length==0)//恢复队列中没有元素时的初始值q1.length=1;  
        {  
            q1.length++;q2.length++;  
        }  
        q1.length++;q2.length++;//每次入队数组元素个数+1  
        if (q1.tail==q1.length)//队尾指针既然已经指向当前数组最后一个元素的下一个位置  
        {  
            q1.tail=0;//那么元素只能插入Array[0]最后一个元素，原因在Init_queue函数注释中。  
            q1.Array[q1.tail]=x;  
        }   
        else  
        {  
            q1.Array[q1.tail]=x;  
            q1.tail++;  
            if (q1.tail==MAX)//若队尾指针指向数组最后一个元素的下一个位置  
            {  
                q1.length--;q2.length--;//由于两个队列元素个数是从1开始的，那么主和辅助队列元素个数已经超过MAX，所以需要调整为MAX，以便下次入队时插入到Array[0]这个位置  
            }  
        }  
        return q1.tail;  
    }  
 }  
 //出栈  
 int pop()  
 {  
     int x=0;  
     if (q1.length<=0)//如果主队列里面有0个元素，那么说明不能进行出队（出栈）操作，直接返回错误提示  
     {  
         cerr<<"underflow"<<endl;  
         return -1;  
     }   
     else  
     {  
         if (q1.tail==0)//通常情况需要返回的是队头指针作为出队元素，那么这里为什么返回队尾指针？因为我们需要用两个队列实现一个栈，那么有n个元素的主栈，把n-1个元素传递给辅助队列后，最后入队的也是将要出栈的元素肯定在主栈队尾。  
         {  
            x=q1.Array[q1.tail];//队尾指针指向0时（其实指向的就是数组最后一位，因为初始化是从1开始的），直接返回Array[0]  
         }  
         else  
         {  
            x=q1.Array[q1.tail-1];//队尾指针指向其它时，由于队尾指针总是指向数组最后一个数据的下一位，那么需要返回的是数组最后一个数据，所以要-1.  
         }  
         while(q1.tail!=q1.head)//队头和队尾相等时，说明已经遍历了整个队列，所以退出循环  
         {  
               
             q2.Array[q2.tail]=q1.Array[q1.head];//将主栈的数据传递给辅助栈  
             if (q2.tail==MAX)//由于需要循环遍历队列，所以当队尾等于数组所能容纳的最大元素个数时，队尾指针自动调整到数组第一个位置。  
             {  
                 q2.tail=0;  
             }  
             else  
             {  
                 q2.tail++;  
             }  
             if (q1.head==MAX)//和上面的if-else类似。  
             {  
                 q1.head=0;  
             }  
             else  
             {  
                 q1.head++;  
             }  
         }  
         if (q1.tail==0)//如果队尾指针等于0，自动指向当前主队列的最后一个元素的下一个位置  
         {  
             q1.tail=q1.length;//这样在下次出队时能够返回队列的最后一个元素。  
         }  
         else  
         {  
             q1.tail--;//如果队尾指针不等于0，那么当前主队列队尾下标指向下一个需要出队的元素。  
         }  
         swap(q1,q2);//原来的主队列转换为辅助队列，原来的辅助队列转换为主队列。  
         q1.tail=q2.tail;//由于转换后，原主队列队尾下标变为辅助队列队尾下标，所以需要将当前辅助队列队尾下标传递给主队列  
         q2.head=q2.tail=1;//辅助队列里的元素个数保持不变，然后其指针恢复为初始状态。由于辅助队列只是起到一个临时保存队列中数据的作用，所以每次主队列有元素出队，就需要初始化辅助队列一下。  
         q1.length--;q2.length--;//每次出队后，需要将辅助和主队列当前拥有的元素个数-1.  
         return x;//主队列队尾元素出队（相当于出栈）  
     }  
 }  
 void swap(struct queue &q1,struct queue &q2)//辅助队列与主队列之间转换  
 {  
   struct queue temp;  
   temp=q1;  
   q1=q2;  
   q2=temp;  
 }  
 void main()  
 {  
     int x=0;  
     Init_queue(q1);  
     Init_queue(q2);  
     srand( (unsigned)time( NULL ) );  
     cout<<"数组中的数据入栈中。。。";  
     for( int j=0; j <= 100; j++ )      // 这个循环就是一个看起来很酷的小程序，其实实际作用没有。^_^  
     {  
         cout.width(3);  
         cout << j << "%";  
         Sleep(40);  
         cout << "\b\b\b\b";//\b退格符号  
     }  
     cout << "\n\n";  
     cout<<"Array=";  
     for (int i=0;i<MAX;i++)//对于开始q1和q2两个空栈来说，设置q1为主栈，q2为辅助栈  
     {  
         x=rand()%100;  
         int t=push(q1.Array,x);  
         if (t==-1)//既然队列已满，那么提示不能入栈后，自动跳出循环。  
         {  
             break;  
         }  
         if (q1.tail==0)  
         {  
             cout<<q1.Array[q1.tail]<<" ";  
         }   
         else  
         {  
             cout<<q1.Array[q1.tail-1]<<" ";  
         }  
     }  
     cout<<endl;  
     cout<<"所有数据入栈完毕！"<<endl;  
     cout<<endl;  
     cout<<"数组中的数据出栈中。。。";  
     for(  j=0; j <= 100; j++ )      // 打印百分比   
     {  
         cout.width(3);  
         cout << j << "%";  
         Sleep(40);  
         cout << "\b\b\b\b";//\b退格符号  
     }  
     cout << "\n\n";  
     cout<<"Array=";  
     for ( i=0;i<MAX;i++)  
     {  
         cout<<pop()<<" ";  
     }  
     cout<<endl;  
     cout<<"所有数据出栈完毕！"<<endl;  
     cout<<endl;  
 }  