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

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

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

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

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

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

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

1 如何用两个栈实现队列

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

入队：元素插入stack1;

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

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

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

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

Java实现代码如下

public class QueueByStack<E extends Comparable<E>>  {
	
	private LinkedList stack1=null;
	private LinkedList stack2=null;
	
	//constructor
	public QueueByStack(){
		stack1=new LinkedList();
		stack2=new LinkedList();
	}//end QueueByStack
		
	public void insert(E e){
          stack1.addLast(e);
	}//end insert()
	
	public E remove(){
		if(!isEmpty()){
			if(stack2.isEmpty()){
				stack1Tostack2();
			}//end if

			return (E)stack2.removeLast();
		}//end if
		else{
			System.out.println("queue is empty");
			return null;
		}//end else
	}//end remove
	
	//将stack1中元素入栈stack2
	private void stack1Tostack2(){
		while(!stack1.isEmpty()){
			stack2.addLast(stack1.removeLast());
		}//end while	
	}//end stack1ToStack2()
	
	public boolean isEmpty(){
		return stack1.isEmpty() && stack2.isEmpty();
	}//end isEmpty()
	
	public int size(){
		return (stack1.size()+stack2.size());
	}//end size()

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		QueueByStack q=new QueueByStack();
		q.insert(1);
		q.insert(2);
		q.insert(3);
		System.out.println(q.remove());
		System.out.println(q.remove());
		q.insert(4);
		System.out.println(q.remove());
		System.out.println(q.remove());
	}
}

2 如何用两个队列实现栈

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

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

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

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

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

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

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

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

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

public class Stack<E extends Comparable<E>> {
	
	private LinkedList<E> heartStack=new LinkedList<E>(); 
	private LinkedList<E> curMinStack=new LinkedList<E>(); //辅助栈，用于记录当前最小值
	private LinkedList<E> curMaxStack=new LinkedList<E>(); //辅助栈，用于记录当前最大值
	
	public void push(E e){
           heartStack.push(e);
           //当前最小值入栈curMinStack
           E currentMin=curMinStack.peek();
           if(currentMin.compareTo(e)>0){
        	   curMinStack.push(e);
           }//end if
           else
        	   curMinStack.push(currentMin);
           
           //当前最大值入栈curMinStack
           E currentMax=curMinStack.peek();
           if(currentMax.compareTo(e)<0){
        	   curMaxStack.push(e);
           }//end if
           else
        	   curMaxStack.push(currentMax);
	}//end push()
	
	public E pull(){
		if(isEmpty())
			return null;
		else{
			E e=heartStack.poll();
			curMinStack.poll();
			curMaxStack.poll();
			return e;
		}//end else
	}//end pull()
	
	public E getMax(){
		return curMaxStack.peek();
	}//end getMax()
	
	public E getMin(){
		return curMinStack.peek();
	}//end getMin()
	
	public int size(){
		return heartStack.size();
	}//end size()
	
	public boolean isEmpty(){
		return heartStack.isEmpty();
	}//end isEmpty()
	
	public E getMedian(){
		E[] e=(E[]) heartStack.toArray();
		Arrays.sort(e);
		return e[e.length/2];
	}//end getMedian()
	
	public E[] toArray(){
		return (E[])heartStack.toArray();
	}//end toArray()
}

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中已实现的可以获取最大值和最小值的栈）：

public class ExmaPeekableQueue<E extends Comparable<E>>  implements IExamPeekableQueue{
	Stack stack1=new Stack();
	Stack stack2=new Stack();
	
	@Override
	public void enqueue(Comparable e) {
		stack1.push(e);		
	}//end enqueue()

	@Override
	public Comparable<E> dequeue() {
		if(stack2.isEmpty()){
			stack2.push(stack1.pull());
		}//end if
		
		return stack2.pull();
	}//end dequeue()

	@Override
	public Comparable<E> peekMedian() {
		Comparable[] arr=null; //用于存储队列中当前元素的数组
		
		if(stack1.isEmpty()){
			arr=stack2.toArray();
		}//end if
		else if(stack2.isEmpty()){
			arr=stack1.toArray();
		}//end if
		else{
			arr=new Comparable[size()];
			Comparable[] arrE1=stack1.toArray();
			Comparable[] arrE2=stack2.toArray();
			
			//将2个栈中的元素复制到一个数组中
			int i=0;
            for(;i<stack1.size();i++){
            	arr[i]=arrE1[i];
            }//end for
            
            for(int j=0;j<stack2.size();j++){
            	arr[++i]=arrE2[j];
            }//end for
		}//end else
			
		Arrays.sort(arr);
		return arr[arr.length/2];
	}//end peekMedian()

	@Override
	public Comparable peekMaximum() {
		Comparable max1=stack1.getMax();
		Comparable max2=stack2.getMax();
		
		if(max1.compareTo(max2)>0){
			return max1;
		}//end if
		else
			return max2;
	}

	@Override
	public Comparable<E> peekMinimum() {
		Comparable min1=stack1.getMin();
		Comparable min2=stack2.getMin();
		
		if(min1.compareTo(min2)>0){
			return min2;
		}//end if
		else
			return min1;
	}//end peekMinimum()

	@Override
	public int size() {
		return (stack1.size()+stack2.size());
	}//end size()
}//end class