算法 1.3.46 栈的可生成性问题

即禁止栈中出现a<b<c排列

所以对每个要入栈的元素进行判断，如果栈中有两个比他小的元素则禁止入栈

判断栈中的两个最小的元素：

1.在每次push的时候全部遍历一遍，复杂度O(n)

2.类中维护两个变量min1，min2，分别表示最小，次小，那么

在每次push时候更新这两个变量，复杂度O(1)

在每次pop的时候更新这两个变量，有:

1.把min1，min2其中之一pop出去了，那么stack中两个最小的变量变了，要重新遍历找回这两个值，复杂度O(n)

2.并没有pop出去，无需遍历

我采用的是方法一

package Cap1;


public class StackPro<Item extends Comparable<Item> >{

	/**
	 * @param args
	 */
	private Node first;
	private int N;
	private class Node{
		Item item;
		Node next;
	}
	public boolean isEmpty(){
		return first == null;
	}
	public int size(){
		return N;
	}
	private boolean check(Item item){
		if(N<2) return true;
		Node cur = first;
		Item min1, min2;
		if(cur.item.compareTo(cur.next.item)<0){
			min1 = cur.item;
			min2 = cur.next.item;
		}
		else {
			min1 = cur.next.item;
			min2 = cur.item;
		}
		
		for(cur = cur.next.next;cur!=null; cur = cur.next){
			if(cur.item.compareTo(min2)<0){
				if(cur.item.compareTo(min1)>0)
					min2 = cur.item;
				else {
					min2 = min1;
					min1 = cur.item;
				}
			}
		}
		return min2.compareTo(item)<=0;
	}
	public void push(Item item){
		if(check(item)==false) return; 
		Node oldfirst = first;
		first = new Node();
		first.item = item;
		first.next = oldfirst;
		N++;
	}
	public Item peek(){
		if(N==0) return null;
		return first.item;
	}
	public Item pop(){
		Item item = first.item;
		first = first.next;
		N -- ;
		return item;
	}

}