java算法day12

java算法day12

• 199二叉树的右视图
• 637二叉树的层平均值
• 515 在每个树行中找最大值
• 429 N叉树的层序遍历
• 116 填充每个节点的下一个右侧节点指针

---

199 二叉树的右视图

这题还是层序遍历的板子，但是在处理上略有差异

这个题我一开始的想法就有误，因为我一开始是基于这个图去想了。以为只要光扩展每层最后一个节点就完事了。然而实际上是错误的。如果按照这种想法，当上面的图中，如果没有4这个节点，那么5这个节点是根本加不到结果集里面。所以这个思路不可取。

正确思路：
为了防止出现上面的情况，那就是左边也是可以扩展的，所以正确的处理是。每一层，每个节点都是需要扩展的，但是只有每层的最后一个元素要加入结果集。
最后一个元素要加入结果集怎么写？
每一层都用到了size，那么for循环的时候注意计数，到最后一个的时候进行结果收集就行了。

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        Deque<TreeNode> que = new ArrayDeque<>();
        if(root==null){
            return result;
        }
        
        que.offerLast(root);
        while(!que.isEmpty()){
            int size = que.size();
            for(int i = 0;i<size;i++){
                TreeNode temp = que.pollFirst();
                if(i==size-1){
                    result.add(temp.val);
                }
                
                if(temp.left!=null){
                    que.offerLast(temp.left);
                }
                if(temp.right!=null){
                    que.offerLast(temp.right);
                }
                


            }
        }

        return result;

    }
}

---

637二叉树的层平均值

就是每层求个平均值。还是板子题

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> result = new ArrayList<>();
        Deque<TreeNode> que = new ArrayDeque<>();
        if(root==null){
            return result;
        }

        que.offerLast(root);
        while(!que.isEmpty()){
            int size = que.size();
            double sum = 0;
            double avg = 0;
            for(int i = 0;i<size;i++){
                TreeNode temp = que.pollFirst();
                sum += temp.val;
                if(temp.left!=null){
                    que.offerLast(temp.left);
                }
                if(temp.right!=null){
                    que.offerLast(temp.right);
                }
                
            }
            avg = sum/size;
            result.add(avg);
        }

        return result;
    }
}

---

515 在每个树行中找最大值

也是模板题，处理每一行的时候维护一个最大值即可。
唯一要记的就是int最小值是Integer.MIN_VALUE。

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        Deque<TreeNode> que = new ArrayDeque<>();
        if(root==null){
            return result;
        }

        que.offerLast(root);
        while(!que.isEmpty()){
            int size = que.size();
            int max = Integer.MIN_VALUE;
            for(int i = 0;i<size;i++){
                TreeNode temp = que.pollFirst();
                if(temp.val > max){
                    max = temp.val;
                }
                if(temp.left!=null){
                    que.offerLast(temp.left);
                }
                if(temp.right!=null){
                    que.offerLast(temp.right);
                }
            }
            result.add(max);
        }

        return result;
    }
}

---

429 N叉树的层序遍历

就是改了一下扩展的方法，不是扩展左右子树了，而是直接把孩子列表加入栈中。
里面用到了一个方法是需要学习的。
ArrayDeque由于实现了Deque，而Deque继承了Queue接口，Queue又继承了Collection接口，所以他具有addAll方法。关于addAll的参数，他的参数类型是Collection类型，者意味着它可以接收任何实现了Collection接口的对象。这就包括了你能想到的单列结构。

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> result = new ArrayList<>();
        Deque<Node> que = new ArrayDeque<>();
        if(root == null){
            return result;
        }

        que.offerLast(root);
        while(!que.isEmpty()){
            int size = que.size();
            List<Integer> curList = new ArrayList<>();
            while(size>0){
                Node temp = que.pollFirst();
                curList.add(temp.val);
                //就是扩展方式变了，变为直接把子节点全部加入到队列中，这也等价于将里面的每个元素从尾部依次加入队列当中。
                que.addAll(temp.children);
                size--;
            }
            result.add(curList);
        }

        return result;
        
    }
}

---

116填充每个节点的下一个右侧节点指针

思路：与层序遍历的差别在于，在处理每一层的时候有变化。到每一层的时候，第一个节点需要单独的拿出来，当然拿出来后也要先进行扩展，因为还有下一层。然后就开始遍历该层剩余的节点。遍历主要还是靠当前que的size来实现的，由于该层第一个节点已经拿出去了，所以遍历的时候i从=1开始。在每个节点处理的过程中要做的就是修改指向。即首节点的next指向后面出栈的第二个节点，然后cur移动到next。并且这个过程中记得扩展左右子节点。

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        Deque<Node> que = new ArrayDeque<>();
        if(root==null){
            return root;
        }

        que.offerLast(root);
        while(!que.isEmpty()){
            //每层先取出第一个节点
            int size = que.size();
            Node cur = que.pollFirst();
            //扩展它
            if(cur.left!=null){
                que.offerLast(cur.left);
            }
            if(cur.right!=null){
                que.offerLast(cur.right);
            }
            for(int i = 1;i<size;i++){
                Node next = que.pollFirst();
                if(next.left!=null){
                    que.offerLast(next.left);
                }
                if(next.right!=null){
                    que.offerLast(next.right);
                }
                cur.next = next;
                cur = next;
            }
            

        }
        return root;
    }
}