1、103. 二叉树的锯齿形层序遍历

昨天做的二叉树的层序遍历，把代码直接拿过来。

这个题要求的是一个Z型遍历，如下图。

        用一个变量f记录正反顺序，然后使用LinkedList记录答案，下图可以看到LinkedList继承了Deque，所以可以当作双端队列来用。

每次记录答案时，根据f的值选择调用offerLast和offerFirst方法。

class Solution {public List<List<Integer>> zigzagLevelOrder(TreeNode root) {LinkedBlockingQueue<TreeNode> q = new LinkedBlockingQueue<>();List<List<Integer>> list = new ArrayList<>();if(root == null) return list;q.offer(root);int cnt = 1;boolean f = true;while(!q.isEmpty()){LinkedList<Integer> L = new LinkedList<>();int temp = 0;for(int i = 0; i < cnt; i++){TreeNode t = q.poll();if(f) L.offerLast(t.val);else L.offerFirst(t.val);if(t.left != null){q.offer(t.left);temp++;}if(t.right != null){q.offer(t.right);temp++;}}cnt = temp;list.add(L);f = !f;}return list;}
}

2、23. 合并 K 个升序链表

        用优先队列来做，默认排序即可（小顶堆），最后处理一下答案，把队列q中的元素转移到新的链表上。

class Solution {public ListNode mergeKLists(ListNode[] lists) {PriorityQueue<Integer> q = new PriorityQueue<>();ListNode head = new ListNode();ListNode p = head;for(int i = 0; i < lists.length; i++){while(lists[i] != null){q.offer(lists[i].val);lists[i] = lists[i].next;}}while(!q.isEmpty()){ListNode t = new ListNode(q.poll());p.next = t;p = p.next;}return head.next;}
}

3、215. 数组中的第K个最大元素

堆这种数据结构就适合求前几个具有xx特性的元素问题，包括下一个题目和最后一个题目。

这个题用小顶堆做，我们可以手写一个堆的结构class MinHeap。

我们只需要把前k个元素加入堆（offer()方法），然后后面的元素只需要判断是否大于堆中的第一个元素即可，如果大于，就替换第一个元素（replace()方法）。

因为堆中第一个元素是k个中最小的，我们不断加入大的元素，那么最后是不是堆中只剩下最大的k个元素了，k个最大元素中最小的不就是堆的第一个元素嘛。

class Solution {public int findKthLargest(int[] nums, int k) {MinHeap heap = new MinHeap(k);for(int i = 0; i < k; i++){heap.offer(nums[i]);}for(int i = k; i < nums.length; i++){if(nums[i] > heap.array[0]){heap.replace(nums[i]);}}return heap.array[0];}
}public class MinHeap {int[] array;int size;public MinHeap(int capacity) {this.array = new int[capacity];}public void offer(int offerd){up(offerd);size++;   }public void up(int offerd){int child = size;while(child > 0){int parent = (child-1)/2;if(array[parent] > offerd){array[child] = array[parent];}else{break;}child = parent;}array[child] = offerd;}public void replace(int replaced){array[0] = replaced;down(0);}private void down(int parent) {int lc = parent*2+1;int rc = lc+1;int min = parent;if(lc < size && array[lc] < array[min]){min = lc;}if(rc < size && array[rc] < array[min]){min = rc;}if(min != parent){swap(min, parent);down(min);}}private void swap(int i, int j) {int t = array[i];array[i] = array[j];array[j] = t;}
}

4、703. 数据流中的第 K 大元素

与上个题不能说一模一样，只能说完全一致。

需要注意add方法要判断一下堆是不是满了，因为初始化堆的时候有可能提供的元素个数小于k个，如果没满直接加入堆就好。

class KthLargest {MinHeap heap = null;public KthLargest(int k, int[] nums) {heap = new MinHeap(k);int len = Math.min(k, nums.length);for(int i = 0; i < len; i++){heap.offer(nums[i]);}for(int i = k; i < nums.length; i++){if(nums[i] > heap.array[0]){heap.replace(nums[i]);}}}public int add(int val) {if(heap.size < heap.array.length){heap.offer(val);}else if(val > heap.array[0]){heap.replace(val);}return heap.array[0];}
}public class MinHeap {int[] array;int size;public MinHeap(int capacity) {this.array = new int[capacity];Arrays.fill(this.array, Integer.MIN_VALUE);}public void offer(int offerd){up(offerd);size++;   }public void up(int offerd){int child = size;while(child > 0){int parent = (child-1)/2;if(array[parent] > offerd){array[child] = array[parent];}else{break;}child = parent;}array[child] = offerd;}public void replace(int replaced){array[0] = replaced;down(0);}private void down(int parent) {int lc = parent*2+1;int rc = lc+1;int min = parent;if(lc < size && array[lc] < array[min]){min = lc;}if(rc < size && array[rc] < array[min]){min = rc;}if(min != parent){swap(min, parent);down(min);}}private void swap(int i, int j) {int t = array[i];array[i] = array[j];array[j] = t;}
}

5、1047. 删除字符串中的所有相邻重复项

解释：
例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。

读完解释后，感觉就是明示了栈的数据结构。

我们把a入栈，b入栈，b入栈，b和栈顶重复，b不入了并且弹出栈顶元素，这时候栈只剩下a，然后a入栈，a和栈顶重复，a不入了并且弹出栈顶元素，栈空了，然后c入栈，a入栈。

这时候我们依次弹出，得到ac，那么我们可以倒着遍历字符串，倒着入栈，结果都是一样的，不影响删除相邻重复的字母。

class Solution {public String removeDuplicates(String s) {Stack<Character> stack = new Stack<>();for(int i = s.length()-1; i >= 0; i--){if(!stack.isEmpty() && stack.peek() == s.charAt(i)){stack.pop();}else{stack.push(s.charAt(i));}}String ans = "";while(!stack.isEmpty()){ans += stack.pop();}return ans;}
}

6、347. 前 K 个高频元素

        元素与元素的次数，让人联想到哈希表。存到哈希表后，对出现的次数进行排序，这应该是第一思路。

        前k个高频元素，有出现了前几个具有xx特性的这种要求，我们就会想到堆，在堆中只存放前k个高频元素，使用小顶堆，我们最后得到的就是前k个最高频的元素了。

        java中的ProrityQueue的底层就是堆，我就不用自己写的了。因为我们的堆中要存储数据和出现的次数，因此可以存个数组，下标0代表是什么数据，下标1代表出现的次数。        

        我们先加入到map中，然后遍历map集合，把cnt大于堆顶的元素替换掉原来的元素，也就是队列出队，这样就得到了前k个高频的元素了。

class Solution {public int[] topKFrequent(int[] nums, int k) {PriorityQueue<int[]> q = new PriorityQueue<>(k, (o1, o2) -> o1[1] - o2[1]);HashMap<Integer, Integer> map = new HashMap<>();for(int i = 0; i < nums.length; i++){int v = 0;if(map.containsKey(nums[i])){v = map.get(nums[i]);}map.put(nums[i], v+1);}for(Integer n : map.keySet()){int cnt = map.get(n);if(q.size() < k){q.offer(new int[]{n, cnt});}else if(cnt > q.peek()[1]){q.poll();q.offer(new int[]{n, cnt});}}int[] ans = new int[k];int j = 0;while(!q.isEmpty()){ans[j++] = q.poll()[0];}return ans;}
}