刷力扣记录

今天的主要内容由两部分组成，一部分是代码随想录[](https://www.programmercarl.com/0098.%E9%AA%8C%E8%AF%81%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91.html#%E9%80%92%E5%BD%92%E6%B3%95)的二叉搜索树，一部分是剑指offer那里的链表和并的题目。先来看代码随想录，二叉搜索树是很有规律的，左子树都小于中间节点，右子树的值都大于中间节点，同时子树也满足这个规律，并且如果是采用中序遍历，那就可以直接变成一个有序的数组。所以第一个做法是直接采用中序遍历，直接放进了数组里面，然后直接在这个向量里面进行操作。

直接看向量的结果。

98. 验证二叉搜索树

class Solution {
    List<Integer> ret = new LinkedList<Integer>();
    public boolean isValidBST(TreeNode root) {
       // 如果是中序，就是从小到大的有序数组
        if(root == null)return false;
        travel(root);
        int len = ret.size();
        System.out.println("len: " + len);
        for(int i = 1; i < len; i++){
            System.out.println(ret.get(i));
            if(ret.get(i) <= ret.get(i - 1)) return false;
        }
        return true;
    }
    void travel(TreeNode cur){
        //中序
        if(cur == null) return;
        travel(cur.left);
        ret.add(cur.val);
        travel(cur.right);
    }

}

可以看到，这个根本用不到这个向量，可不可以直接不用这个向量，因为判断二叉搜索树，其实就是判断这个值是不是连续的增大就行。那就要搞个临时变量，保存前一个节点。有个很关键的点，为什么？if(root == null) return true;很明显，因为中序，要走到最后一个左叶子节点，这时候才开始判断，必须返回true，然后pre记录中间节点，再来判断右叶子节点是不是大于中节点。这样就过去了最低一节，接着往上走。

class Solution {
    
    TreeNode pre = null;
    //保存上一个的结果
    public boolean isValidBST(TreeNode root) {
       // 如果是中序，就是从小到大的有序数组
        if(root == null) return true;
        boolean left = isValidBST(root.left);
        if(pre != null && pre.val >= root.val) return false;
        pre = root;
        boolean right = isValidBST(root.right);
        return left && right;
    }
   

}

接下来的，求搜索树的最小差值，也可以采用前一个节点来计算。直接把if条件换掉就行，直接求当下的最小值就行。这个最小值最好采用全局变量，这方便很多，可以不用返回值就直接递归搞定。

501. 二叉搜索树中的众数

这个我用了很笨的方法，先用map统计次数，然后统计最大次数，得到最大次数的所有key，再把key全部装进去列表里面，再转成数组，确实很啰嗦，也没用到了搜索树的结构。

class Solution {
    Map<Integer, Integer> map = new HashMap<Integer, Integer>();
    List<Integer> vec = new LinkedList<Integer>();
    List<Integer> ret = new LinkedList<Integer>();
    public int[] findMode(TreeNode root) {
        if(root == null) return new int[0];
        travel(root);
        int len = vec.size();
        for(int i = 0; i < len; i++){
            map.put(vec.get(i), map.getOrDefault(vec.get(i), 0) + 1);
        }
        int max = Integer.MIN_VALUE;
        for(Map.Entry<Integer, Integer> entry:map.entrySet()){
            if(entry.getValue() > max){
                max = entry.getValue();
            }
        }
        for(Map.Entry<Integer, Integer> entry:map.entrySet()){
            if(entry.getValue() == max){
                ret.add(entry.getKey());
            }
        }
        return ret.stream().mapToInt(Integer::intValue).toArray();
    }
    void travel(TreeNode cur){
        if(cur == null) return ;
        travel(cur.left);
        vec.add(cur.val);
        travel(cur.right);
    }
}

利用搜索树的相等一定相连的结构，将这个树连接起来。然后判断数值，只要是不相等，重新计数，相等的就个数自增；接着不断去维护全局最大值，只要是新的最大值出现，那就把列表清空，记入新值，否则列表直接加入新值即可。

class Solution {
    List<Integer> list = new LinkedList<Integer>();
    int maxCount = 0;
    int count = 0;
    TreeNode pre = null;
    public int[] findMode(TreeNode root) {
        travel(root);
        
        int len = list.size();
        int[] ret = new int[len];
        for(int i = 0; i < len; i++){
            ret[i] = list.get(i);
        }
        return ret;
    }
    void travel(TreeNode cur){
        if(cur == null) return ;
        travel(cur.left);
        
        //中节点做判断
        if(pre == null || pre.val != cur.val){
            count = 1;
        }else{
            count++;
        }
        //更新结果
        if(count > maxCount){
            maxCount = count;
            list.clear(); //储存的结果不对，全部去掉
            list.add(cur.val);
        }else if(count == maxCount){
            //出现新的众数数值
            list.add(cur.val);
        }
        pre = cur;
        travel(cur.right);
    }
}

合并链表这部分毕竟简单，就不再多写了。