JAVA程序设计：最大频率栈（LeetCode：895）

实现 FreqStack，模拟类似栈的数据结构的操作的一个类。

FreqStack 有两个函数：

push(int x)，将整数 x 推入栈中。
pop()，它移除并返回栈中出现最频繁的元素。
如果最频繁的元素不只一个，则移除并返回最接近栈顶的元素。
 

示例：

输入：
["FreqStack","push","push","push","push","push","push","pop","pop","pop","pop"],
[[],[5],[7],[5],[7],[4],[5],[],[],[],[]]
输出：[null,null,null,null,null,null,null,5,7,5,4]
解释：
执行六次 .push 操作后，栈自底向上为 [5,7,5,7,4,5]。然后：

pop() -> 返回 5，因为 5 是出现频率最高的。
栈变成 [5,7,5,7,4]。

pop() -> 返回 7，因为 5 和 7 都是频率最高的，但 7 最接近栈顶。
栈变成 [5,7,5,4]。

pop() -> 返回 5 。
栈变成 [5,7,4]。

pop() -> 返回 4 。
栈变成 [5,7]。
 

提示：

对 FreqStack.push(int x) 的调用中 0 <= x <= 10^9。
如果栈的元素数目为零，则保证不会调用  FreqStack.pop()。
单个测试样例中，对 FreqStack.push 的总调用次数不会超过 10000。
单个测试样例中，对 FreqStack.pop 的总调用次数不会超过 10000。
所有测试样例中，对 FreqStack.push 和 FreqStack.pop 的总调用次数不会超过 150000。
 

思路：定义两个map，第一个用来存储每种数出现的频率，第二个map存每个x对应的列表，这个列表里存储x分别在那些时候添加进了栈，另外开一个大顶堆用来每次弹出出现频率最高的元素。

class FreqStack {
	
	class node implements Comparable<node>{
		int val,id,num;
		public node(int val,int id,int num) {
			this.val=val;
			this.id=id;
			this.num=num;
		}
		@Override
		public int compareTo(node o) {
			// TODO 自动生成的方法存根
			if(num==o.num)
				return o.id-id;
			return o.num-num;
		}
	}
	
	int size;
	PriorityQueue<node> q;
	Map<Integer,Integer> map;
	Map<Integer,List<Integer>> map2;
	
	
    public FreqStack() {
    	size=0;
    	map=new HashMap<>();
    	map2=new HashMap<>();
    	q=new PriorityQueue<>();
    }
    
    public void push(int x) {
    	map.put(x, map.getOrDefault(x, 0)+1);
		q.add(new node(x,size,map.get(x)+1));
		if(!map2.containsKey(x))
			map2.put(x, new ArrayList<>());
		map2.get(x).add(size++);
    }
    
    public int pop() {
    	while(!q.isEmpty()) {
    		node now=q.poll();
    		int index=map2.get(now.val).get(map2.get(now.val).size()-1);
    		if(now.id>index) 
    			now.id=index;
    		else {
    			q.add(now);
    			break;
    		}
    		q.add(now);
    	}
    	node now=q.poll();
    	map.put(now.val, map.get(now.val)-1);
    	map2.get(now.val).remove(map2.get(now.val).size()-1);
    	return now.val;
    }
}