155.最小栈 |152.乘积最大子数组 | 148.排序链表 | 146.LRU缓存

class MinStack {
    private Stack<Integer> stack;
    private Stack<Integer> minStack;
    public MinStack() {
        stack = new Stack<>();
        minStack = new Stack<>();
    }
   
    public void push(int val) {
        stack.push(val);
        if(minStack.isEmpty() || val <= minStack.peek()){
            minStack.push(val);
        }
    }
    
    public void pop() {
        if(!stack.isEmpty()){
            int pop = stack.pop();
            if(!minStack.isEmpty() && minStack.peek() == pop){
                minStack.pop();
            }
        }
        
    }
    
    public int top() {
        return stack.peek();
    }
    
    public int getMin() {
        if(!minStack.isEmpty()){
            return minStack.peek();
        }
        return -1;
    }
}

class Solution {
    public int maxProduct(int[] nums) {
        int res = nums[0];
        int len = nums.length;
        int max = nums[0];
        int min = nums[0];
        for (int i = 1; i<len ;i++){
            if(nums[i] < 0){
                int temp = max;
                max = min;
                min = temp;
            }
            max = Math.max(nums[i], max*nums[i]);
            min = Math.min(nums[i], min*nums[i]);
            res = Math.max(res, max);
        }
    return res;
    }
}

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode sortList(ListNode head) {
        List<Integer> list = new ArrayList<>();
        ListNode cur = head;
        while(cur != null){
            list.add(cur.val);
            cur= cur.next;
        }
        Collections.sort(list);

        ListNode res = new ListNode(0);
        ListNode rescur = res;
        for(int i : list){
            rescur.next = new ListNode(i);
            rescur = rescur.next;
        }
        return res.next;
    }
}

class LRUCache {
    private HashMap<Integer,Integer> map;
    private int capacity;
    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.map = new LinkedHashMap<Integer,Integer>(capacity,0.75f,true){
            protected boolean removeEldestEntry(Map.Entry<Integer,Integer> eldest){
                return size() > capacity;
            }
        };
    }
    
    public int get(int key) {
        if(map.containsKey(key)){
            return map.get(key);
        }else{
            return -1;
        }
    }
    
    public void put(int key, int value) {
        map.put(key,value);
}}

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */