有趣的题目系列一：实现具有最大值、最小值、中间值的栈和队列

番外知识：Java反射详解

番外二：

<?>是1.5的新特性，泛型
如果是?表示可以放Object类型以及他的子类

如果是String 表示只能接收String以及他的子类。
Class<?> c表示这个Class可以放任意的类,?表示object(所有类都隐性从Object继承的)
Class<String> c 只能接收String和他的子类（本文中的<E>也是这种情况）
Class c和Class<?>c性质是一样的

===========================================

题目来源：

1）http://blog.youkuaiyun.com/bigheadzzy/article/details/8002253

2）http://blog.youkuaiyun.com/yangzhongblog/article/details/12391959

文章中的大部分题目描述、代码均参考自上面二处，加以自己的一些理解。

-------------------------------------------------------------------切割-------------------------------------------------------------------------

Works Applications的笔试题：

要求实现下面两个接口，实现要求：运行速度快，每个操作时间复杂度不能相差太大。

一，实现Immutable的FIFO队列。也就是说要求入队和出队不会改变原来的队列。

package jp.co.worksap.recruiting;

public interface ExamImmutableQueue<E> {
	public ExamImmutableQueue<E> enqueue(E e);
	public ExamImmutableQueue<E> dequeue();
	public E peek();
	public int size();
}

二，实现可以查找最大、最小和中间值的FIFO队列。

public interface ExamPeekableQueue<E extends Comparable<E>> {
	
	public void enqueue(E e);
	public E dequeue();
	public E peekMedian();
	public E peekMaximum();
	public E peekMinimum();
	public int size();
}

接口一要求实现的API有：入队、出队、峰值和大小

接口二要求实现的有：入队、出队、中间值、最小值、最大值和大小

仔细对比，发现接口一和接口二的入队和出队的返回值是不同的。

原作者的代码是这样子的（我自己敲了一遍）：

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.NoSuchElementException;
import java.util.Stack;

public class ExamImmutableQueueImpl<E> implements ExamImmutableQueue<E>{
    /*根据题目的要求是要求入队和出队均不影响原队列，所以这里用了final*/
	private final E[] queue;
    private final int size;
    
    public ExamImmutableQueueImpl(){//构造函数不需要标注<E>
    	queue = null;
    	size = 0;
    }
    public ExamImmutableQueueImpl(E[] queue){
    	this.queue = queue;
    	size = queue.length;
    }
	@Override
	public ExamImmutableQueue<E> enqueue(E e) {
		// TODO Auto-generated method stub
		if(e == null)
			throw new IllegalArgumentException();
		//需要考虑的是在内部变量插入一个新的元素，如何返回一个新的ExamImmutableQueueImpl对象
		//E[] clone = new E[size + 1];Java不可以定义泛型数组，ArrayList或者LinkedList是已经成型的泛型数组
		/*
		 * 可以考虑的一个方法
		 * ArrayList<E> arr = new ArrayList<E>();
		   E[] clone = (E[]) arr.toArray();
		*/
		@SuppressWarnings("unchecked")
		E[] clone = (E[])Array.newInstance(e.getClass(), size + 1);
		clone[0] = e;
		if(size != 0)
			System.arraycopy(queue, 0, clone, 1, size);
		return new ExamImmutableQueueImpl<E>(clone);
	}

	@Override
	public ExamImmutableQueue<E> dequeue() {
		// TODO Auto-generated method stub
		//////////////////////////////////
		/*题目要求的是FIFO，由入队我们得知新元素将被置在内部数组的首位，那删除应该从后面开始删除*/
		if(size == 0)
			throw new NoSuchElementException();
		//E[] clone = (E[]) new Object[size - 1]; 用Object取代也是一种好方法
		@SuppressWarnings("unchecked")
		E[] clone = (E[]) new Object[size - 1];
		System.arraycopy(queue, 0, clone, 0, size - 1);
		return new ExamImmutableQueueImpl<E>(clone);
	}

	@Override
	public E peek() {
		// TODO Auto-generated method stub
		if(size == 0)
			throw new NoSuchElementException();
		return (E) queue[size - 1];
	}

	@Override
	public int size() {
		// TODO Auto-generated method stub
		return this.size;
	}
    
}

第二题：作者的代码：

package jp.co.worksap.recruiting;

import java.util.Collections;
import java.util.LinkedList;
import java.util.NoSuchElementException;

public class ExamPeekableQueueImpl<E extends Comparable<E>> implements
		ExamPeekableQueue<E> {

	private LinkedList<SortedNode> objList = new LinkedList<SortedNode>();
	private SortedNode head = null;
	private SortedNode tail = null;

	class SortedNode implements Comparable<SortedNode>{
		public E e;
		public SortedNode next;
		public SortedNode(E e, SortedNode sn) {
			this.e = e;
			next = sn;
		}
		@Override
		public int compareTo(SortedNode sn) {
			// TODO Auto-generated method stub		
			return this.e.compareTo(sn.e);
		}
	}
	
	private void testNull() {
		if (objList.isEmpty()) {
			head = null;
			tail = null;
			throw new NoSuchElementException("No element");
		}
	}

	@Override
	public void enqueue(E e) {
		// TODO Auto-generated method stub
		if (e == null)
			throw new NoSuchElementException("Null object to eunqueue");
		
		if (head == null) {
			SortedNode sn = new SortedNode(e, null);
			head = sn;
			tail = sn;
			objList.add(sn);
		}
		else {
			SortedNode sn = new SortedNode(e, null);
			tail.next = sn;
			tail = sn;
			objList.add(sn);
			Collections.sort(objList);
		}
	}

	@Override
	public E dequeue() {
		// TODO Auto-generated method stub
		testNull();
		SortedNode sn = head;
		head = head.next;
		objList.remove(sn);
		Collections.sort(objList);
		return sn.e;
	}

	@Override
	public E peekMedian() {
		// TODO Auto-generated method stub
		testNull();
		return objList.get(objList.size()/2).e;
	}

	@Override
	public E peekMaximum() {
		// TODO Auto-generated method stub
		testNull();
		return objList.getLast().e;
	}

	@Override
	public E peekMinimum() {
		// TODO Auto-generated method stub
		testNull();
		return objList.getFirst().e;
	}

	@Override
	public int size() {
		// TODO Auto-generated method stub
		return objList.size();
	}

}

个人感觉是使用的策略较为原始。

下面是另一篇博文的转载：

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

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  

========================

当然如果知识为了实现栈的最大值最小值中间值功能，而不要求使用队列，那完全可以使用内部栈解决。

在上面的博文中，使用两个队列（数组）实现的栈的先入后出功能，

可以有两种实现模式：

当在Array1 输入1 2 3 之后要删除3 则需要借助Array2 -> Array1:空  Array2为 1 2

这个时候新来的元素应该插入到Array1 还是Array2呢。

如果是插入到Array2 则，若后面需要删除某元素，则必须整个数组移到Array1

如果是插入到Array1 则只需要将后面输入的移到Array2。这是个较为优化的方案。