代码随想录day13：二叉树part2，层序遍历，翻转，对称

最新推荐文章于 2024-08-05 16:41:06 发布

O_ra_Cle

最新推荐文章于 2024-08-05 16:41:06 发布

阅读量216

点赞数 9

分类专栏：代码随想录文章标签： java 算法数据结构

本文链接：https://blog.csdn.net/O_ra_Cle/article/details/136078925

版权

代码随想录专栏收录该内容

46 篇文章 0 订阅

订阅专栏

文章介绍了二叉树和N叉树的层序遍历算法，包括普通层序、自底向上层序遍历，以及如何计算二叉树的右视图、层平均值、每个树行的最大值。还涉及了节点指针填充、二叉树翻转和对称性判断等实用操作。

摘要由CSDN通过智能技术生成

文章目录

- day13：二叉树part2，层序遍历，翻转&对称

day13：二叉树part2，层序遍历，翻转&对称

102.二叉树的层序遍历

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

107.二叉树的层序遍历 II

从最底层往上层遍历，把上一题的结果数组反转一下

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

199.二叉树的右视图

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

637.二叉树的层平均值

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

429.N 叉树的层序遍历

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> ans = new ArrayList<>();
        if (root == null) return ans;
        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            List<Integer> level = new ArrayList<>();
            int len = queue.size();
            while (len-- > 0) {
                Node node = queue.poll();
                level.add(node.val);
                List<Node> children = node.children;
                if (children == null) continue;
                for (Node child : children) {
                    if (child != null)
                        queue.offer(child);
                }
            }
            ans.add(level);
        }
        return ans;
    }
}

515.在每个树行中找最大值

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

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

class Solution {
    public Node connect(Node root) {
        if (root == null) return root;
        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int len = queue.size();
            Node pre = queue.poll();
            if (pre.left != null) queue.offer(pre.left);
            if (pre.right != null) queue.offer(pre.right);
            for (int i = 1; i < len; i++) {
                Node node = queue.poll();
                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
                pre.next = node;
                pre = node;
            }
        }
        return root;
    }
}

117.填充每个节点的下一个右侧节点指针 II

class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) return 0;
        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }
}

111.二叉树的最小深度

class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) return 0;
        // 左右孩子都不为空
        else if (root.left != null && root.right != null)
            return Math.min(minDepth(root.left), minDepth(root.right)) + 1;
        // 左右孩子中有空，空节点返回0，加上不影响
        else return minDepth(root.left) + minDepth(root.right) + 1;
    }
}

226.翻转二叉树

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

    public void swapChildren(TreeNode node) {
        TreeNode tmp = node.left;
        node.left = node.right;
        node.right = tmp;
    }
}

101.对称二叉树

其实是后序遍历的逻辑

class Solution {
    public boolean isSymmetric(TreeNode root) {
        return compare(root.left, root.right);
    }

    public boolean compare(TreeNode left, TreeNode right) {
        if (left == null && right == null) return true;
        else if (left != null && right == null) return false;
        else if (left == null && right != null) return false;
        else if (left.val != right.val) return false;
        else {
            boolean outside = compare(left.left, right.right);
            boolean inside = compare(left.right, right.left);
            return outside && inside;
        }
    }
}