965. 单值二叉树 / 剑指 Offer II 059. 数据流的第 K 大数值 / 剑指 Offer II 060. 出现频率最高的 k 个数字

965. 单值二叉树【简单题】【每日一题】

思路：

递归中序遍历二叉树，定义一个全局变量flag，初值为true，遍历过程中发现与标定值不同时将flag置为false，最后返回flag。

代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    boolean flag;
    public boolean isUnivalTree(TreeNode root) {
        flag = true;
        dfs(root,root.val);
        return flag;
    }
    public void dfs(TreeNode root,int val){
        if(root == null){
            return;
        }
        dfs(root.left,val);
        if(root.val != val){
            flag = false;
        }
        dfs(root.right,val);
    }
}

---

剑指 Offer II 059. 数据流的第 K 大数值【简单题】

思路：【优先队列】

构造函数使用优先队列存储数据流中的元素，优先队列会默认帮我们将输入的元素按从小到大的顺序排列。保持优先队列的大小为k，当超过k时将队列头部元素删除。
调用add函数时，将val加入队列，并判断此时队列大小是否超过k，如果是，将队列头部元素删除，返回此时队列的头部元素即为数据流中第 k大元素。

代码：

class KthLargest {

    int k;
    PriorityQueue<Integer> pq;

    public KthLargest(int k, int[] nums) {
        this.k = k;
        this.pq = new PriorityQueue<>();
        for(int n : nums){
            pq.offer(n);
        }
        while(pq.size() > k){
            pq.poll();
        }
    }
    
    public int add(int val) {
        pq.offer(val);
        if(pq.size() > k){
            pq.poll();
        }
        return pq.peek();
    }
}

/**
 * Your KthLargest object will be instantiated and called as such:
 * KthLargest obj = new KthLargest(k, nums);
 * int param_1 = obj.add(val);
 */

---

剑指 Offer II 060. 出现频率最高的 k 个数字【中等题】

思路：【优先队列+哈希map+哈希set】

刚用优先队列做完上题，这题就又用上了，不过我看题解用的是堆排序和基数排序，害，不管这些了，懒得看。

代码：

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        //定义一个map用来记录nums中每个元素及对应的出现次数
        Map<Integer,Integer> map = new HashMap<>();
        for (int num : nums) {
            map.put(num, map.getOrDefault(num,0)+1);
        }
        //定义优先队列pq用来存储nums中每个元素出现次数，并将其截断为长度为k
        //根据优先队列的性质，此时仍处于队列中的次数 即为出现频率前k高的次数，我们只需找出这些次数对应的元素即可
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for (Integer cnt : map.values()) {
            pq.offer(cnt);
        }
        while (pq.size() > k){
            pq.poll();
        }
        int[] ans = new int[k];
        int i = 0;
        //定义set用来存储出现这些频率前k高的次数
        Set<Integer> set = new HashSet<>(pq);
        //遍历map，将每个元素对应的出现次数与set中次数进行比对
        for (Integer key : map.keySet()) {
            //如果当前元素的次数在set中存在，则说明这个元素就是出现频率前k高的元素，将其存入数组ans中
            if (set.contains(map.get(key))){
                ans[i++] = key;
            }
        }
        //返回答案数组ans
        return ans;
    }
}