算法练习（栈、堆、队列）

1.

//最小栈
    class MinStack {

        Deque<Integer> stack;
        Deque<Integer> minStack;

        /** initialize your data structure here. */
        public MinStack() {
           stack = new LinkedList<Integer>();
           minStack = new LinkedList<Integer>();
           minStack.push(Integer.MAX_VALUE);
        }

        public void push(int x) {
            stack.push(x);
            minStack.push(Math.min(minStack.peek(),x));
        }

        public void pop() {
            stack.pop();
            minStack.pop();
        }

        public int top() {
            return stack.peek();
        }

        public int getMin() {
           return minStack.peek();
        }
    }

2.

//数组中的第K个最大元素
    public int findKthLargest(int[] nums, int k) {
        Arrays.sort(nums);
        int count = 0;
        int tmp = Integer.MAX_VALUE;
        for (int i = nums.length - 1; i >= 0; i--) {
            if (nums[i] < tmp){
                tmp = nums[i];
                count++;
            }else if (nums[i] == tmp){
                count++;
            }
            if (count == k){
                return tmp;
            }
        }
        return Integer.MAX_VALUE;
    }

3.

 //数据流的中位数
    class MedianFinder {


        private Queue<Integer> left = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        private Queue<Integer> right = new PriorityQueue<>();

        /** initialize your data structure here. */
        public MedianFinder() {

        }

        public void addNum(int num) {
           if (left.size() == right.size()){
               if (left.size() == 0){
                   left.add(num);
               }else if (num <= right.peek()){
                   left.add(num);
               }else {
                   left.add(right.poll());
                   right.add(num);
               }
           }else {
               if (num >= left.peek()){
                   right.add(num);
               }else {
                   right.add(left.poll());
                   left.add(num);
               }
           }
        }

        public double findMedian() {
              if (left.size() > right.size()){
                  return (double)left.peek();
              }else {
                  return (double)(left.peek() + right.peek()) / 2.0;
              }
        }
    }

4.

//有序矩阵中第K小的元素
    public int kthSmallest(int[][] matrix, int k) {
        Queue<Integer> queue = new PriorityQueue<>();
        for (int[] ints : matrix) {
            for (int anInt : ints) {
                queue.add(anInt);
            }
        }
        for (int i = 0; i < k - 1; i++) {
            queue.poll();
        }
        return queue.peek();
    }

5.

//前 K 个高频元素
    public int[] topKFrequent(int[] nums, int k) {
        HashMap<Integer,Integer> map = new HashMap<>();
        for (int num : nums) {
            map.put(num,map.getOrDefault(num,0)+1);
        }

        Queue<int[]> queue = new PriorityQueue<>(new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[1] - o2[1];
            }
        });
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            int num = entry.getKey();
            int count = entry.getValue();
            if (queue.size() == k){
                if (count > queue.peek()[1]){
                    queue.poll();
                    queue.offer(new int[]{num,count});
                }
            }else {
                queue.offer(new int[]{num,count});
            }
        }

        int[] knums = new int[k];
        for (int i = 0; i < knums.length; i++) {
             knums[i] = queue.poll()[0];
        }
        return knums;
    }

6.

//滑动窗口最大值
    public int[] maxSlidingWindow(int[] nums, int k) {
        int n = nums.length;
        PriorityQueue<int[]> pq = new PriorityQueue<int[]>(new Comparator<int[]>() {
            public int compare(int[] pair1, int[] pair2) {
                return pair1[0] != pair2[0] ? pair2[0] - pair1[0] : pair2[1] - pair1[1];
            }
        });
        for (int i = 0; i < k; ++i) {
            pq.offer(new int[]{nums[i], i});
        }
        int[] ans = new int[n - k + 1];
        ans[0] = pq.peek()[0];
        for (int i = k; i < n; ++i) {
            pq.offer(new int[]{nums[i], i});
            while (pq.peek()[1] <= i - k) {
                pq.poll();
            }
            ans[i - k + 1] = pq.peek()[0];
        }
        return ans;
    }

7.

 //基本计算器 II
    public int calculate(String s) {
        Stack<Integer> stack = new Stack<>();
        char lastcop = '+';
        char[] arr = s.toCharArray();
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == ' '){
                continue;
            }
            if (Character.isDigit(arr[i])){
                int tempNum = arr[i] - '0';
                while ( i+1 < arr.length && Character.isDigit(arr[i+1])){
                    tempNum = tempNum * 10 + arr[i+1] - '0';
                    i++;
                }
                if (lastcop == '+'){
                    stack.push(tempNum);
                }else if (lastcop == '-'){
                    stack.push(-tempNum);
                }else {
                    stack.push(res(lastcop,stack.pop(),tempNum));
                }
            }else {
                lastcop = arr[i];
            }
        }
        int total = 0;
        for (Integer integer : stack) {
            total += integer;
        }
        return total;
    }
    
    private int res(char op, int a, int b) {
        if (op == '*'){
            return a * b;
        }else {
            return a / b;
        }
    }

8.

//扁平化嵌套列表迭代器
    public class NestedIterator implements Iterator<Integer> {

        private  List<NestedInteger> list;
        private  Deque<Integer> stack;

        public NestedIterator(List<NestedInteger> nestedList) {
            this.list = nestedList;
            stack = new ArrayDeque<>();
            instance(list);
        }

        @Override
        public Integer next() {
           return stack.poll();
        }

        @Override
        public boolean hasNext() {
           if (stack.isEmpty()){
               return false;
           }
           return true;
        }

        private void instance(List<NestedInteger> list){
            for (int i = 0; i < list.size(); i++) {
                if (list.get(i).isInteger()){
                    stack.offer(list.get(i).getInteger());
                }else {
                    instance(list.get(i).getList());
                }
            }
        }
    }

    public interface NestedInteger {
        public boolean isInteger();
        public Integer getInteger();
        public List<NestedInteger> getList();
   }

9.

//逆波兰表达式求值
   public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
       for (int i = 0; i < tokens.length; i++) {
           String str = tokens[i];
           if (str.length() > 1){
               stack.push(Integer.parseInt(str));
           }else if (Character.isDigit(str.charAt(0))){
               stack.push(Integer.parseInt(str));
           }else {
               int a = stack.pop();
               int b = stack.pop();
               if (tokens[i].equals("+")){
                   stack.push(b+a);
               }else if (tokens[i].equals("-")){
                   stack.push(b-a);
               }else if (tokens[i].equals("*")){
                   stack.push(b*a);
               }else {
                       stack.push(b/a);
               }
           }
       }
       return stack.pop();
   }