Day85（二叉树的层序遍历、滑动窗口）

102、二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）

 根据队列的特点：先进先出

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>>res=new ArrayList<>();
        Queue<TreeNode>queue=new LinkedList<>();
        if(root==null) return res;
        queue.offer(root);
        while(!queue.isEmpty()){
            int len=queue.size();
            List<Integer>list=new ArrayList<>();
            while(len>0){
                TreeNode temp=queue.poll();
                list.add(temp.val);
                if(temp.left!=null) queue.offer(temp.left);
                if(temp.right!=null) queue.offer(temp.right);
                len--;
            }
            res.add(list);
        }
        return res;
    }
}

226、翻转二叉树 

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

 翻转的思路和代码如下：

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root==null) return root;
        if(root.left==null&&root.right==null) return root;
        TreeNode temp=root.left;
        root.left=invertTree(root.right);
        root.right=invertTree(temp);
        return root;
    } 
}

513、找树左下角的值 

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。假设二叉树中至少有一个节点。

 层序遍历比较容易

法一：层序遍历先进先出，先进队列：左节点再进右节点。而我们要求的是最后一层的第一个节点，即最后一次进队列的第一个节点，故if(i==0) res=temp.val;

class Solution {
    public int findBottomLeftValue(TreeNode root) {
        int res=0;
        Queue<TreeNode>queue=new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size=queue.size();
            for(int i=0;i<size;i++){
                TreeNode temp=queue.poll();
                if(i==0) res=temp.val;
                if(temp.left!=null) queue.offer(temp.left);
                if(temp.right!=null)queue.offer(temp.right);
            }
        }
        return res;
    }
}

法二：队列先进先出，先进队列：右节点再左节点，当遍历结束后，最后一个节点进队列，那么这个节点就是我们要求的 

class Solution {
    public int findBottomLeftValue(TreeNode root) {
        int res=0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        TreeNode temp = new TreeNode(-100);
        while (!queue.isEmpty()) {
            temp = queue.poll();
            res=temp.val;
            if (temp.right != null) {
                queue.offer(temp.right);//先把右节点加入 queue
            }
            if (temp.left != null) {
                queue.offer(temp.left); //再把左节点加入 queue
            }
        }
        return res;
    }
}

908、最小差值 I

其中 x 是一个范围为 [-k, k] 的整数。对于每个索引 i ，最多 只能 应用 一次 此操作。 
当最小值加上k比最大值减去k还要大，那么说明最小值可以通过调节k的值（k∈[-k, k]）使得两者最大值减最小值为0。故当min>max时，直接return 0【例子：示例3】

class Solution {
    public int smallestRangeI(int[] nums, int k) {
        int max= Arrays.stream(nums).max().getAsInt()-k;
        int min=Arrays.stream(nums).min().getAsInt()+k;
        if(max-min>0){
            return max-min;
        }else{
            return 0;
        }
    }
}

1052、爱生气的书店老板（滑动窗口）

关键点： 因为有X分钟可以控制情绪，所以这X分钟要用到如下：哪个长度为X的时间段不满意的客人最多。最多客户数量等于原本满意客户+X时间段内因为控制了情绪而态度反转的最多客户数量

if(grumpy[i]==0){
   total+=customers[i];
   customers[i]=0;
}

class Solution {
    public int maxSatisfied(int[] customers, int[] grumpy, int minutes) {
        int sum=0,max=0,index=0;
        int left=0,right=0;
        int total=0;
        for(int i=0;i<grumpy.length;i++){
            if(grumpy[i]==0){
                total+=customers[i];
                customers[i]=0;//关键就是：在给定的minutes里找到连续的生气值
                //因为有X分钟可以控制情绪，所以这X分钟要用到如下：哪个长度为X的时间段不满意的客人最多
                //最多客户数量等于原本满意客户+X时间段内因为控制了情绪而态度反转的最多客户数量
            }
        }

        while(right<customers.length){
            sum+=customers[right];
            right++;
            while(right-left>=minutes){
                if(sum>max){
                    max=sum;
                    index=left;
                }
                sum-=customers[left];
                left++;
            }
        }

        return total+max;
    }
}

1305、两棵二叉搜索树中的所有元素

给你 root1 和 root2 这两棵二叉搜索树。请你返回一个列表，其中包含 两棵树 中的所有整数并按 升序 排序。

 暴力解法

/**
 * 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 {
    List<Integer>list=new ArrayList<>();
    public List<Integer> getAllElements(TreeNode root1, TreeNode root2) {
        if(root1==null&&root2==null) return list;
        infixOrder(root1);
        infixOrder(root2);
        Collections.sort(list);
        return list;

    }
    public void infixOrder(TreeNode root){
        if(root==null) return ;
        infixOrder(root.left);
        list.add(root.val);
        infixOrder(root.right);
    }
}