力扣Day28

485、最大连续 1 的个数

给定一个二进制数组 nums ， 计算其中最大连续 1 的个数。

class Solution {
    public int findMaxConsecutiveOnes(int[] nums) {
        int max=0;
        int count=0;
        for(int i=0;i<nums.length;i++){
            if(nums[i]==1){
                count++;
            }else{
                count=0;
            }
            max=Math.max(max,count);
        }
        return max;
    }
}

501、二叉搜索树中的众数

给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。如果树中有不止一个众数，可以按 任意顺序 返回。

 因为题目说的是二叉搜索树，由于二叉搜索树的定义可知：该树的中序遍历是一个递增的、有序的序列

二叉搜索树的中序遍历序列是 { -1, 0, 0, 1, 2, 2 }。

所以采用中序遍历，每次遍历一个结点，就计数（count）并与最大值（max）比较元素出现的次数，最后添加到集合里，然后转成数组输出。

进行单层逻辑的时候，只看根结点，左右结点的中序遍历就行。即：0、1、2

/**
 * 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 {
    private List<Integer> list=new ArrayList<>();
    private int count;
    private int max ;
    private TreeNode pre;

    public int[] findMode(TreeNode root) {
        count=0;//
        max=1;//假设每一个结点的值都不一样,那么每一个元素出现的次数都是1
        pre=null;
        infixOrder(root);
        int j=0;
        int res[]=new int[list.size()];
        for(int i:list){
            res[j++]=i;
        }
        return res;
    }

    private void infixOrder(TreeNode root){//中序遍历
       if(root==null) return ; //终止条件1
       infixOrder(root.left);
       if(pre!=null&&root.val==pre.val){
           count++;
       }else{
           count=1;
       }
       if(max==count){//如果树中有不止一个众数,就添加进去
           list.add(root.val);
       }else if(max<count){
           list.clear();
           list.add(root.val);
           max=count;
       }
       pre=root;//后移结点

       infixOrder(root.right);
    }
}

 530、二叉搜索树的最小绝对差

给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。差值是一个正数，其数值等于两值之差的绝对值。

 

如果是求左右节点的最小值是应该直接递归 getMinimumDifference (root.left)和 getMinimumDifference (root.right)，不需要遍历所有结点。

而题目是求 树中任意两不同节点值的差值  故要遍历所有结点。

∵该树是二叉搜索树

∴使用中序遍历

注意细节：int min=Integer.MAX_VALUE;  因为是求最小值，所以最小值的初始值不要设为0，设为Integer的最大值比较妥当。

（一般最大值的初始值是0，最小值的初始值是Integer.MAX_VALUE）

/**
 * 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 {
    private int min;
    private TreeNode pre;

    public int getMinimumDifference(TreeNode root) {
        min=Integer.MAX_VALUE;//因为是求最小值，所以最小值的初始值不要设为0，设为Integer的最大值比较妥当
        pre=null;
        infixOrder(root);
        return min;
        
    }
    public void infixOrder(TreeNode root){//中序遍历
        if(root==null) return;
        infixOrder(root.left);
        if(pre!=null){
            min=Math.min(min,Math.abs(pre.val-root.val));
        }
        pre=root;//后移结点
        infixOrder(root.right);
    }
}