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

1两个栈实现一个队列

1.原理分析：

队列的主要操作有两个：入队操作和出队操作，出队时从队头出，入队是从队尾插入，入队的操作和入栈的操作类似，而最关键的问题是出队操作，要出队列的是队列的第一个元素，而出栈的是栈的栈顶元素，所以我们可以这样：

       假设两个栈A和栈B，A主要用来处理入队操作，B用于处理出队操作。入队操作和入栈操作类似，直接将元素压入栈即可。出队的时候，实现我们假设栈B为空，则要把栈A的第一个元素（即栈底元素）弹出，直接从A弹出这是不可能的，但如果我们把栈A里面的元素的顺序逆过来，这样直接用栈弹出栈顶元素即可，所以我们可以把栈A的元素全部弹出来，并俺顺序压入栈B中，这样每次栈B弹出的栈顶元素就是栈A相对应的栈底元素，就是出队操作。若B不为空，则代表之前从A复制过来的元素还没有完全弹出，要出栈的时候直接弹出即可。若栈B的元素都弹出来了，就需要从A中补充。

 2.总结操作就是：    

入队：将元素进栈A

出队：判断栈B是否为空，如果为空，则将栈A中所有元素pop，并push进栈B，栈B出栈；如果不为空，栈B直接出栈。

3.Java代码实现

1. import java.util.Stack;  
2.   
3. public class StacksToQueue   
4. {  
5.      Stack<Integer> stack1=new Stack<Integer>() ;  
6.      Stack<Integer> stack2=new Stack<Integer>();  
7.      public void addToTail(int x)//添加元素到队尾   --进队---  
8.      {  
9.          stack1.push(x);  
10.            
11.      }  
12.      public int deleteHead()//删除对首      --出队---    不需是队不为空才能删除呀~~~~  
13.      {  
14.          if( pSize()!=0)//队列不为空  
15.          {  
16.              if(stack2.isEmpty())//若stack2为空，则把stack1全部加入stack2  
17.                  stack1ToStack2();   
18.              return  stack2.pop();  
19.                
20.          }  
21.          else  
22.          {  
23.              System.out.println("队列已经为空，不能执行从队头出队");  
24.              return -1;  
25.          }  
26.            
27.      }  
28.        
29.      public void stack1ToStack2()//把stack1全部放入stack2  
30.      {  
31.          while(!stack1.isEmpty())   
32.              stack2.push(stack1.pop());  
33.      }  
34.        
35.      public int pSize()//队列size()  
36.      {  
37.          return  stack1.size()+stack2.size();//两个都为空队列才是空  
38.      }  
39.    
40. }    

2两个队列实现一个栈

1. 原理分析：

栈的主要操作有两个：入栈操作和出栈操作，出栈时从栈顶出，入栈是从栈顶插入。入栈和入队类似，都是从“所有元素后面插入”；而最关键的问题是出栈操作，要出栈的是的栈顶元素，而队列每次出队的是队列的第一个元素。因此我们可以这样，出队的时候，若队列不止一个元素，则进行出队 操作，只保留最后一个元素，这样出队的时候，就符合出栈的要求了，但其他的元素必须 保留，而且顺序不能乱，这时候另一个队列就起作用了，这个队列可以在“出栈”操作之前按顺序保留所有的元素，等到“出栈”之后，把所有元素按顺序进入到“出栈”后的队列。因此两个队列总有一个为空。

2.总结操作就是：

入栈：将元素进队列A

出栈：判断队列A中元素的个数是否为1，如果等于1，则出队列，否则将队列A中的元素  以此出队列并放入队列B，直到队列A中的元素留下一个，然后队列A出队列，再把  队列B中的元素出队列以此放入队列A中。

3.Java代码实现：

1. import java.util.LinkedList;  
2.   
3. public class QueuesToStack   
4. {  
5.     LinkedList<Integer> queue1=new LinkedList<Integer>();  
6.     LinkedList<Integer> queue2=new LinkedList<Integer>();  
7.     public void push(int value)//入栈  
8.     {  
9.         queue1.addLast(value);  
10.           
11.     }  
12.       
13.     public int pop()//出栈     必须是非空的栈才能出栈啊  
14.     {  
15.         if(sSize()!=0)//栈不为空  
16.         {  
17.             //移动一个队的n-1个到另一个中  
18.             if(!queue1.isEmpty())//q1 空  
19.             {  
20.                 putN_1ToAnthor();  
21.                 return queue1.removeFirst();  
22.             }  
23.             else  //q2 空  
24.             {  
25.                 putN_1ToAnthor();  
26.                 return queue2.removeFirst();  
27.             }          
28.         }  
29.         else  
30.         {  
31.             System.out.println("栈已经为空啦，不能出栈");  
32.             return -1;  
33.         }  
34.           
35.     }  
36.       
37.     public int sSize()  
38.     {  
39.         return queue1.size()+queue2.size();  
40.     }  
41.       
42.     public void putN_1ToAnthor()//从非空中出队n-1个到另一个队列   因为队列总是一空一非空  
43.     {  
44.         if(!queue1.isEmpty())  
45.         {  
46.             while(queue1.size()>1)  
47.             {  
48.                 queue2.addLast(queue1.removeFirst());  
49.             }  
50.         }  
51.         else if(!queue2.isEmpty())  
52.         {  
53.             while(queue2.size()>1)  
54.             {  
55.                 queue1.addLast(queue2.removeFirst());  
56.             }  
57.         }  
58.     } 
59. }