如何实现具有最大值、最小值和中间值的栈和队列

转自：http://blog.csdn.net/yangzhongblog/article/details/12391959#comments

在研究“如何实现具有最大值、最小值和中间值的栈和队列”前，我们先考虑以下问题，然后由此过度到题目问题。

1）如何用两个栈实现队列

2）如何用两个队列实现栈

3）如何实现包含获取最小值函数getMin()的栈

4）如何实现包含获取中间值函数getMedian()的栈

5）如何实现包含获取最小值函数getMin()的队列

1 如何用两个栈实现队列

在研究问题前，我们可以用2个栈模拟一下具体操作过程，可以总结出以下规律：

入队：元素插入stack1;

出队：如果stack2中为空，先将stack1中元素入栈stack2，然后再将stack2的栈顶元素出栈。否则直接将stack2中元素出栈。

队列为空：stack1和stack2同时为空

队列大小：为stack1和stack2大小之和

具体过程见下图（图来自《剑指offer》）

Java实现代码如下

[java]  view plain copy

1. public class QueueByStack<E extends Comparable<E>>  {  
2.       
3.     private LinkedList stack1=null;  
4.     private LinkedList stack2=null;  
5.       
6.     //constructor  
7.     public QueueByStack(){  
8.         stack1=new LinkedList();  
9.         stack2=new LinkedList();  
10.     }//end QueueByStack  
11.           
12.     public void insert(E e){  
13.           stack1.addLast(e);  
14.     }//end insert()  
15.       
16.     public E remove(){  
17.         if(!isEmpty()){  
18.             if(stack2.isEmpty()){  
19.                 stack1Tostack2();  
20.             }//end if  
21.   
22.             return (E)stack2.removeLast();  
23.         }//end if  
24.         else{  
25.             System.out.println("queue is empty");  
26.             return null;  
27.         }//end else  
28.     }//end remove  
29.       
30.     //将stack1中元素入栈stack2  
31.     private void stack1Tostack2(){  
32.         while(!stack1.isEmpty()){  
33.             stack2.addLast(stack1.removeLast());  
34.         }//end while      
35.     }//end stack1ToStack2()  
36.       
37.     public boolean isEmpty(){  
38.         return stack1.isEmpty() && stack2.isEmpty();  
39.     }//end isEmpty()  
40.       
41.     public int size(){  
42.         return (stack1.size()+stack2.size());  
43.     }//end size()  
44.   
45.     /** 
46.      * @param args 
47.      */  
48.     public static void main(String[] args) {  
49.         QueueByStack q=new QueueByStack();  
50.         q.insert(1);  
51.         q.insert(2);  
52.         q.insert(3);  
53.         System.out.println(q.remove());  
54.         System.out.println(q.remove());  
55.         q.insert(4);  
56.         System.out.println(q.remove());  
57.         System.out.println(q.remove());  
58.     }  
59. }  

2 如何用两个队列实现栈

还是先用2个队列模拟栈的出栈和入栈过程，可以得出以下规律：

入栈：压入非空的那个队列

出栈：将非空队列中的n-1个元素压入空的队列中，然后将第n个元素出栈。

具体过程见下图（图来自《剑指offer》）

3 如何实现包含获取最小值函数的栈

问题：定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的getMin函数。在该栈中，调用getMin、push及pop的时间复杂度都是O(1).

思路：用一个辅助栈stack2记住每次入栈stack1的当前最小值:在stack1入栈时，往stack2中加入当前最小值；stack1元素出栈时，stack2也出栈一个元素。最小值从stack2中获取及栈顶元素。

4 如何实现包含获取中间值函数的栈

如果能对栈中元素进行排序，那么排序好的中间值即为所求。问题3和问题4的具体代码如下，代码中同时实现了获取栈的最大值、最小值和中间值

[java]  view plain copy

1. public class Stack<E extends Comparable<E>> {  
2.       
3.     private LinkedList<E> heartStack=new LinkedList<E>();   
4.     private LinkedList<E> curMinStack=new LinkedList<E>(); //辅助栈，用于记录当前最小值  
5.     private LinkedList<E> curMaxStack=new LinkedList<E>(); //辅助栈，用于记录当前最大值  
6.       
7.     public void push(E e){  
8.            heartStack.push(e);  
9.            //当前最小值入栈curMinStack  
10.            E currentMin=curMinStack.peek();  
11.            if(currentMin.compareTo(e)>0){  
12.                curMinStack.push(e);  
13.            }//end if  
14.            else  
15.                curMinStack.push(currentMin);  
16.              
17.            //当前最大值入栈curMinStack  
18.            E currentMax=curMinStack.peek();  
19.            if(currentMax.compareTo(e)<0){  
20.                curMaxStack.push(e);  
21.            }//end if  
22.            else  
23.                curMaxStack.push(currentMax);  
24.     }//end push()  
25.       
26.     public E pull(){  
27.         if(isEmpty())  
28.             return null;  
29.         else{  
30.             E e=heartStack.poll();  
31.             curMinStack.poll();  
32.             curMaxStack.poll();  
33.             return e;  
34.         }//end else  
35.     }//end pull()  
36.       
37.     public E getMax(){  
38.         return curMaxStack.peek();  
39.     }//end getMax()  
40.       
41.     public E getMin(){  
42.         return curMinStack.peek();  
43.     }//end getMin()  
44.       
45.     public int size(){  
46.         return heartStack.size();  
47.     }//end size()  
48.       
49.     public boolean isEmpty(){  
50.         return heartStack.isEmpty();  
51.     }//end isEmpty()  
52.       
53.     public E getMedian(){  
54.         E[] e=(E[]) heartStack.toArray();  
55.         Arrays.sort(e);  
56.         return e[e.length/2];  
57.     }//end getMedian()  
58.       
59.     public E[] toArray(){  
60.         return (E[])heartStack.toArray();  
61.     }//end toArray()  
62. }  

5 如何实现包含获取最小值函数的队列

问题：定义队列的数据结构，请在该类型中实现一个能够得到队列的最小元素的getMin函数。在该队列中，调用getMin、insert及remove的时间复杂度都是O(1).

思路1：用最小堆实现优先队列，获取最小值时间复杂度为O(nlogn)，但优先队列只能获取最小值，remove获取的不是先入队的元素。

思路2：

如果能用栈有效地实现队列，而栈的获取最小值的操作又很容易实现，那么队列的获取最小值的操作也很容易完成。

因为上面可用2个栈实现栈的min函数，而用2个栈可以实现队列。所以可以用已实现了获取最小值的栈stack1和stack2实现队列，而整个队列的最小值从min(stack1.getMin(),stack2.getMin())中获取。具体实现代码见问题6中代码。

6 如何实现具有最大值、最小值和中间值的栈和队列

问题5解决了用O(1)时间获取栈的最小值，那么解决最大值的问题也迎刃而解。对于获取队列的中间值，可以将队列中所有元素排序，然后获取排序后的中间值。

具体实现如下（代码中的stack类为上述问题4中已实现的可以获取最大值和最小值的栈）：

[java]  view plain copy

1. public class ExmaPeekableQueue<E extends Comparable<E>>  implements IExamPeekableQueue{  
2.     Stack stack1=new Stack();  
3.     Stack stack2=new Stack();  
4.       
5.     @Override  
6.     public void enqueue(Comparable e) {  
7.         stack1.push(e);       
8.     }//end enqueue()  
9.   
10.     @Override  
11.     public Comparable<E> dequeue() {  
12.         if(stack2.isEmpty()){  
13.             stack2.push(stack1.pull());  
14.         }//end if  
15.           
16.         return stack2.pull();  
17.     }//end dequeue()  
18.   
19.     @Override  
20.     public Comparable<E> peekMedian() {  
21.         Comparable[] arr=null; //用于存储队列中当前元素的数组  
22.           
23.         if(stack1.isEmpty()){  
24.             arr=stack2.toArray();  
25.         }//end if  
26.         else if(stack2.isEmpty()){  
27.             arr=stack1.toArray();  
28.         }//end if  
29.         else{  
30.             arr=new Comparable[size()];  
31.             Comparable[] arrE1=stack1.toArray();  
32.             Comparable[] arrE2=stack2.toArray();  
33.               
34.             //将2个栈中的元素复制到一个数组中  
35.             int i=0;  
36.             for(;i<stack1.size();i++){  
37.                 arr[i]=arrE1[i];  
38.             }//end for  
39.               
40.             for(int j=0;j<stack2.size();j++){  
41.                 arr[++i]=arrE2[j];  
42.             }//end for  
43.         }//end else  
44.               
45.         Arrays.sort(arr);  
46.         return arr[arr.length/2];  
47.     }//end peekMedian()  
48.   
49.     @Override  
50.     public Comparable peekMaximum() {  
51.         Comparable max1=stack1.getMax();  
52.         Comparable max2=stack2.getMax();  
53.           
54.         if(max1.compareTo(max2)>0){  
55.             return max1;  
56.         }//end if  
57.         else  
58.             return max2;  
59.     }  
60.   
61.     @Override  
62.     public Comparable<E> peekMinimum() {  
63.         Comparable min1=stack1.getMin();  
64.         Comparable min2=stack2.getMin();  
65.           
66.         if(min1.compareTo(min2)>0){  
67.             return min2;  
68.         }//end if  
69.         else  
70.             return min1;  
71.     }//end peekMinimum()  
72.   
73.     @Override  
74.     public int size() {  
75.         return (stack1.size()+stack2.size());  
76.     }//end size()  
77. }//end class