力扣打卡day12

二叉树的常见题目

1.144. 二叉树的前序遍历
方法一：递归法

class Solution {
    List<Integer> res=new LinkedList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
        traverse(root);
        return res;
    }
    public void traverse(TreeNode root){
        if(root==null){
            return ;
        }
        res.add(root.val);
        traverse(root.left);
        traverse(root.right);
    }
}

方法二：非递归（迭代法）

// 前序遍历顺序：中-左-右，入栈顺序：中-右-左
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if (node.right != null){
                stack.push(node.right);
            }
            if (node.left != null){
                stack.push(node.left);
            }
        }
        return result;
    }
}

94. 二叉树的中序遍历
方法一：递归法

class Solution {
    List<Integer> res=new LinkedList<>();
    public List<Integer> inorderTraversal(TreeNode root) {
        traverse(root);
        return res;
    }
    public void traverse(TreeNode root){
        if(root==null){
            return ;
        }
        traverse(root.left);
        res.add(root.val);
        traverse(root.right);
    }
}

方法二：非递归（迭代法）

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()){
           if (cur != null){
               stack.push(cur);
               cur = cur.left;
           }else{
               cur = stack.pop();
               result.add(cur.val);
               cur = cur.right;
           }
        }
        return result;
    }
}

145. 二叉树的后序遍历
方法一：递归法

class Solution {
    List<Integer> res=new LinkedList<>();
    public List<Integer> postorderTraversal(TreeNode root) {
        traverse(root);
        return res;
    }
    public void traverse(TreeNode root){
        if(root==null){
            return ;
        }
        traverse(root.left);
        traverse(root.right);
        res.add(root.val);
    }
}

方法二：非递归（迭代法）

// 后序遍历顺序 左-右-中 入栈顺序：中-左-右 出栈顺序：中-右-左， 最后翻转结果
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if (node.left != null){
                stack.push(node.left);
            }
            if (node.right != null){
                stack.push(node.right);
            }
        }
        Collections.reverse(result);
        return result;
    }
}

102. 二叉树的层序遍历

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> q=new LinkedList<>();
        List<List<Integer>> res=new ArrayList();
        if(root!=null){
            q.offer(root);
        }
        while(!q.isEmpty()){
            int size=q.size();
            List<Integer> level=new ArrayList();
            for(int i=0;i<size;i++){
                TreeNode cur=q.poll();
                level.add(cur.val);
                if(cur.left!=null){
                    q.offer(cur.left);
                }
                if(cur.right!=null){
                    q.offer(cur.right);
                }
            }
            res.add(level);
        }
        return res;
    }
}

107.二叉树的层次遍历II
先层序遍历，在反转数组即可

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        Queue<TreeNode> q=new LinkedList<>();
        List<List<Integer>> res=new ArrayList<>();
        if(root!=null){
            q.offer(root);
        }
        while(!q.isEmpty()){
            int size=q.size();
            List<Integer> level=new ArrayList<>();
            for(int i=0;i<size;i++){
                TreeNode cur=q.poll();
                level.add(cur.val);
                if(cur.left!=null){
                    q.offer(cur.left);
                }
                if(cur.right!=null){
                    q.offer(cur.right);
                }
            }
            res.add(level);
        }
        List<List<Integer>> result = new ArrayList<>();
        for(int i=res.size()-1;i>=0;i--){
            result.add(res.get(i));
        }
        return result;
    }
}

199.二叉树的右视图
层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进level数组中，随后返回result就可以了。

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        Queue<TreeNode> q=new LinkedList<>();
        List<Integer> level=new ArrayList<>();
        if(root!=null){
            q.offer(root);
        }
        while(!q.isEmpty()){
            int size=q.size();
            for(int i=0;i<size;i++){
                TreeNode cur=q.poll();
                if(cur.left!=null){
                    q.offer(cur.left);
                }
                if(cur.right!=null){
                    q.offer(cur.right);
                }
                if(i==size-1){
                    level.add(cur.val);
                }
            }
            
        }
        return level;
    }
}

637.二叉树的层平均值
本题就是层序遍历的时候把一层求个总和在取一个均值。

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        Queue<TreeNode> q=new LinkedList<>();
        List<Double> level=new ArrayList<>();
        if(root!=null){
            q.offer(root);
        }
        while(!q.isEmpty()){
            int size=q.size();
            double levelSum=0.0;
            for(int i=0;i<size;i++){
                TreeNode cur=q.poll();
                levelSum+=cur.val;
                if(cur.left!=null){
                    q.offer(cur.left);
                }
                if(cur.right!=null){
                    q.offer(cur.right);
                }  
            }
            level.add(levelSum/size);
        }
        return level;
    }
}

429. N 叉树的层序遍历

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        Queue<Node> q=new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();
        if(root!=null){
            q.offer(root);
        }
        while(!q.isEmpty()){//队列中没有元素层序遍历就终止了
            int size=q.size();//记录队列大小的个数就是每层有几个元素
            List<Integer> level=new ArrayList<>();
            for(int i=0;i<size;i++){
                Node cur=q.poll();
                level.add(cur.val);
                List<Node> children=cur.children;
                if (children == null || children.size() == 0) {
                    continue;
                }
                for(Node child:children){
                    if(child!=null){
                        q.offer(child);
                    }
                }
            }
            res.add(level);
        }
        return res;
    }
}