day14|层序遍历

层序遍历这里我犯了一个错误：
正确的应该是：

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

我写的时候，写成了：
 

            while(len-->0){
                TreeNode node = queue.poll();
                if(node != null){
                list2.add(node);
                queue.offer(node.left);
                queue.offer(node.right)
                }
            }

这样会有一个问题就是，在最后一轮遍历的时候，left和right都是空但是依然被offer进了queue，导致queue不是空的，让！queue。isEmpty()这个条件成立了，循环还在继续，就出现了这种情况：

107自底而上.在原来的基础上加一个

Collections.reverse(list);

199右视图.把层序遍历每层的最后一个组成list

list.add(list2.get(list2.size() - 1));

637.层平均，非常简单

                double avg = 0;
                double sum = 0;
                for(int i = 0; i< list2.size();i++){
                    sum = sum + list2.get(i);
                }
                avg = sum/list2.size();
                list.add(avg);

429N叉树 把每个孩子都遍历了

for(Node _children:node.children){
                    if(_children != null)
                        queue.offer(_children);
            }

515每层最大值 

                Collections.sort(list2);
                list.add(list2.get(list2.size() - 1));

116、117填充下一个右节点指针（不会）

本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了

class Solution {
    public Node connect(Node root) {
	Queue<Node> tmpQueue = new LinkedList<Node>();
	if (root != null) tmpQueue.add(root);

	while (tmpQueue.size() != 0){
	    int size = tmpQueue.size();

            Node cur = tmpQueue.poll();
            if (cur.left != null) tmpQueue.add(cur.left);
            if (cur.right != null) tmpQueue.add(cur.right);

	    for (int index = 1; index < size; index++){
		Node next = tmpQueue.poll();
		if (next.left != null) tmpQueue.add(next.left);
		if (next.right != null) tmpQueue.add(next.right);

                cur.next = next;
                cur = next;
	    }
	}

        return root;
    }
}

104最大深度

return list.size();

111最小深度

当左子树和右子树都是null时，就是最小深度。

226 翻转二叉树

这道题用递归非常简单，

class Solution {
    public TreeNode invertTree(TreeNode root) {
        reverse(root);
        return root;
    }

    public void reverse(TreeNode root){
        if(root==null){
            return;
        }
        TreeNode node = root.right;
        root.right = root.left;
        root.left = node;
        reverse(root.left);
        reverse(root.right);
    }
    
}

用迭代法的话，也可以认为是层序遍历的变体，就是把层序遍历每层的交换了就可以，就加了一段相当于

class Solution {
    public TreeNode invertTree(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        if(root != null){
            queue.offer(root);
        }
        while(queue.size() != 0){
            int len = queue.size();
            while(len -- >0){
                TreeNode node = queue.poll();
                TreeNode temp = node.left;
                node.left = node.right;
                node.right = temp;
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right != null){
                    queue.offer(node.right);
            }
        }
    }
    return root;
    }  
}

101.对称二叉树

class Solution {
    public boolean isSymmetric(TreeNode root) {
        return helper(root.left,root.right);
    }
    public boolean helper(TreeNode left,TreeNode right){
        if(left != null && right == null){
            return false;
        }
        if(right != null && left == null){
            return false;
        }
        if(left == null && right == null){
            return true;
        }
        if(left.val != right.val){
            return false;
        }
        boolean result1 = helper(left.left,right.right);
        boolean result2 =helper(left.right,right.left);
        return result1 && result2;
    }
}

由个要注意的点：

  if(left.val != right.val){
            return false;
        }

应该写到后面