数据结构

一、栈

问题：largest-rectangle-in-histogram

描述：

思路：构造一个递增栈，一旦push入栈的元素比栈顶元素小的时候，就计算包括栈顶元素的面积最大值。

public class Solution {
    /**
     * @param height: A list of integer
     * @return: The area of largest rectangle in the histogram
     */
    public int largestRectangleArea(int[] height) {
        // write your code here
        if(height==null||height.length==0)
        return 0;
        Stack<Integer> stack =new Stack<>();
        int max = 0;
        for(int i=0;i<=height.length;i++){
            int tem =(i==height.length)?-1:height[i];
            while(!stack.isEmpty()&&height[stack.peek()]>tem){
                int h = height[stack.pop()];
                int w = stack.isEmpty()?i:i-stack.peek()-1;
                max = Math.max(max,h*w);
            }
            stack.push(i);
        }
        return max;
    }
}

---

二、哈希表

                              

LRU缓存策略(Least recently used,最近最少使用)

思路：把双向链表和HashMap结合起来

public class LRUCache {
    /*
    * @param capacity: An integer
    */
    public class Node{
        Node pre ;
        Node next ;
        public int val;
        public int key;
        public Node(int key,int val){
            this.val = val;
            this.key = key;
            pre = null;
            next = null;
        }
        
    }
    
    private int capacity;
    private Node head;
    private Node tail;
    private Map<Integer,Node> map;
    
    public LRUCache(int capacity) {
        // do intialization if necessary
        this.capacity = capacity;
        head = new Node(-1,-1);
        tail = new Node(-1,-1);
        map = new HashMap<Integer,Node>();
        head.next = tail;
        tail.pre = head;
    }

    /*
     * @param key: An integer
     * @return: An integer
     */
    public int get(int key) {
        // write your code here
        if(!map.containsKey(key))
        return -1;
        Node node = map.get(key);
          node.pre.next = node.next;
        node.next.pre = node.pre;
        move2Tail(node);
     //   System.out.println("key="+key+",value="+node.val);
        return node.val;
  
    }
    
    public void move2Tail(Node node){
      
        node.pre = tail.pre;
        tail.pre.next = node;
        node.next = tail;
        tail.pre = node;
   
    }
    
    /*
     * @param key: An integer
     * @param value: An integer
     * @return: nothing
     */
    public void set(int key, int value) {
        // write your code here
        if(map.containsKey(key)){
            Node temp = map.get(key);
            temp.pre.next = temp.next;
            temp.next.pre = temp.pre;
            move2Tail(temp);
            temp.val = value;
            return;
        }
        if(map.size()==capacity){
            map.remove(head.next.key);
            head.next.next.pre = head;
            head.next = head.next.next;
        }
        Node cur = new Node(key,value);
        map.put(key,cur);
      //   System.out.println("SET   key="+key+",value="+cur.val);
        move2Tail(cur);
    }
}

 

三、heap

Add 插入的时候，将需要插入的元素放在最下面一层最左边的空位。在跟父节点比较，如果比父节点小则一直交换。

Remove的时候，把最后一排最右边的点于根节点交换，并且把那个位置的数删除，然后不断与其小一点的子节点交换，不断重复。

PriorityQueue

题目：丑数

思路：通过PriorityQueue和HashMap实现

public class Solution {
    /**
     * @param n: An integer
     * @return: the nth prime number as description.
     */
    public int nthUglyNumber(int n) {
        // write your code here
        if(n==1)
        return 1;
        PriorityQueue<Integer> que = new PriorityQueue<>();
        Map<Integer,Integer> map = new HashMap<>();
        Integer[] uglys = new Integer[3];
        uglys[0] = Integer.valueOf(2);
        uglys[1] = Integer.valueOf(3);
        uglys[2] = Integer.valueOf(5);
        for(int i=0;i<3;i++){
            que.add(uglys[i]);
            map.put(uglys[i],1);
        }
        Integer tem = Integer.valueOf(0);
        for(int i=1;i<n;i++){
            tem = que.poll();
            for(int j=0;j<3;j++){
                if(tem*uglys[j]<Integer.MAX_VALUE&&!map.containsKey(tem*uglys[j])){
                    que.add(tem*uglys[j]);
                    map.put(tem*uglys[j],1);
                }
            }
            
        }
        return tem;
    }
}

题目二、前K大的数2

public class Solution {
    /*
    * @param k: An integer
   
    */
    
     private PriorityQueue<Integer> que;
     private int k;

    public Solution(int k) {
        // do intialization if necessary
        this.k = k;
      que = new PriorityQueue<>(k,new Comparator<Integer>(){
            public int compare(Integer a1,Integer a2){
                return a1-a2;}
            });

        
    }

    /*
     * @param num: Number to be added
     * @return: nothing
     */
    public void add(int num) {
        // write your code here
        if(que.size()<k){
            que.add(num);
         
        }else{
            if(num>que.peek()){
               que.poll();
                que.add(num);
            
            }
            
        }
    }

    /*
     * @return: Top k element
     */
    public List<Integer> topk() {
        // write your code here
        int size = que.size();
        Integer[] arr = new Integer[size];
        for(int i=size-1;i>=0;i--){
            arr[i] = que.poll();
        }
         for(int i=0;i<size;i++){
            que.add(arr[i]);
        }
        return Arrays.asList(arr);
    }
}