day14 111. 二叉树的最小深度&&104. 二叉树的最大深度&&116. 填充每个节点的下一个右侧节点指针&&117. 填充每个节点的下一个右侧节点指针 II&&515. 在每个树行中找最大值&&429. N 叉树的层序遍历&&637. 二叉树的层平均值&&199. 二叉树的右视图&&107. 二叉树的层序遍历 II&&102. 二叉树的层序遍历

//111. 二叉树的最小深度
public int minDepth(TreeNode root) {
//递归实现，效率不高8ms
/if (root == null) return 0;
if (root.left == null && root.right == null) return 1;//处理叶子结点就是根节点的情况
return Math.min(min(root.left), min(root.right)) + 1;//处理叶子结点不是根节点的情况/
//迭代实现，效率比递归高2ms
if (root == null) return 0;
int depth=1;
Queue queue=new LinkedList<>();
queue.add(root);
while(!queue.isEmpty()){
int size=queue.size();
for(int i=0;i<size;i++){
TreeNode node=queue.poll();
if (node.leftnull && node.rightnull) return depth;
if(node.left!=null) queue.add(node.left);
if(node.right!=null) queue.add(node.right);
}
depth++;
}
return -1;//这行代码不会被执行
}
private int min(TreeNode root) {
if (root == null) return Integer.MAX_VALUE;
if (root.left == null && root.right == null) return 1;
return Math.min(min(root.left), min(root.right)) + 1;
}
//104. 二叉树的最大深度
public int maxDepth(TreeNode root) {
if (root == null) return 0;
return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;//每一层都+1返回，即加上本身所在的这一层
}
//117. 填充每个节点的下一个右侧节点指针 II
public Node connect1(Node root) {
if (root == null) {
return null;
}
Node cur = root;
while (cur != null) {
Node head = new Node();//每一层的头结点（哨兵节点）
Node tail=head;//用于连接每一层形成链表，尾插法
while (cur != null) {//遍历这一层，连接下一层
if (cur.left != null) {
tail.next = cur.left;
tail = cur.left;
}
if (cur.right != null) {
tail.next = cur.right;
tail = cur.right;
}
cur = cur.next;//跳转至下一个结点
}
cur = head.next;//跳转至下一层头结点
}
return root;
}
//116. 填充每个节点的下一个右侧节点指针
public Node connect(Node root) {
/if (root == null) {
return null;
}
Queue queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
List list = new ArrayList<>();
int size = queue.size();
for (int i = 0; i < size; i++) {
Node node = queue.poll();
if (node!=null) {
list.add(node);
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
}
for (int i = 0; i < list.size()-1; i++) {
list.get(i).next=list.get(i+1);
}
}
return root;/
if (root == null) {
return null;
}
Node cur = root;
while (cur != null) {
Node head = new Node(0),//头指针
tail = head;//用于连接一层元素
for (Node i = cur; i != null; i = i.next) {
if (i.left != null)
tail = tail.next = i.left;
if (i.right != null)
tail = tail.next = i.right;
}
cur = head.next;//一层已形成链表的第一个元素
}
return root;
}
//515. 在每个树行中找最大值
public List largestValues(TreeNode root) {
List res = new ArrayList<>();
if (root == null) {
return res;
}
Queue queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
int size = queue.size();
int max = Integer.MIN_VALUE;
for (int i = 0; i < size; i++) {
TreeNode node = queue.poll();
if (node != null) {
if (max < node.val) {
max = node.val;
}
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
}
res.add(max);
}
return res;
}

//429. N 叉树的层序遍历
public List<List<Integer>> levelOrder(N_Node root) {
    List<List<Integer>> res = new ArrayList<>();
    if (root == null) return res;
    Queue<N_Node> queue = new LinkedList<>();
    queue.add(root);
    while (!queue.isEmpty()) {
        List<Integer> list = new ArrayList<>();
        int size = queue.size();
        for (int i = 0; i < size; i++) {
            N_Node node = queue.poll();
            list.add(node.val);
            if (node.children != null&& !node.children.isEmpty()) {
                queue.addAll(node.children);
            }
        }
        res.add(list);
    }
    return res;
}

//637. 二叉树的层平均值
public List<Double> averageOfLevels(TreeNode root) {
    List<Double> res = new ArrayList<>();
    if (root == null) {
        return res;
    }
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    while (!queue.isEmpty()) {
        int size = queue.size();
        double sum = 0.0;
        for (int i = 0; i < size; i++) {
            TreeNode node = queue.poll();
            if (node != null) {
                sum += node.val;
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
        }
        res.add(sum / size);
    }
    return res;
}

//199. 二叉树的右视图
public List<Integer> rightSideView(TreeNode root) {
    //利用层序遍历解决
    /*List<Integer> res = new ArrayList<>();
    if (root == null) {
        return res;
    }
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    while (!queue.isEmpty()) {
        List<Integer> list = new ArrayList<>();
        int size = queue.size();
        for (int i = 0; i < size; i++) {
            TreeNode node = queue.poll();
            if (node!=null) {
                list.add(node.val);

                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
        }
        res.add(list.get(list.size()-1));
    }
    return res;*/
    //递归实现
    List<Integer> ans = new ArrayList<>();
    dfs(root, 1, ans);
    return ans;
}

private void dfs(TreeNode root, int depth, List<Integer> ans) {
    if (root == null) {
        return;
    }
    if (depth > ans.size()) { // 这个深度首次遇到
        ans.add(root.val);
    }
    dfs(root.right, depth + 1, ans); // 先递归右子树，保证首次遇到的一定是最右边的节点
    dfs(root.left, depth + 1, ans);
}

//107. 二叉树的层序遍历 II
public List<List<Integer>> levelOrderBottom(TreeNode root) {
    List<List<Integer>> res = new ArrayList<>();
    if (root == null) {
        return res;
    }
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    while (!queue.isEmpty()) {
        List<Integer> list = new ArrayList<>();
        int size = queue.size();
        for (int i = 0; i < size; i++) {
            TreeNode node = queue.poll();
            if (node != null) {
                list.add(node.val);

                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
        }
        res.add(list);
    }
    Collections.reverse(res);
    return res;
}

//102. 二叉树的层序遍历
public List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> res = new ArrayList<>();
    if (root == null) {
        return res;
    }
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    while (!queue.isEmpty()) {
        List<Integer> list = new ArrayList<>();
        int size = queue.size();
        for (int i = 0; i < size; i++) {
            TreeNode node = queue.poll();
            if (node != null) {
                list.add(node.val);

                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
        }
        res.add(list);
    }
    return res;
}