【Leetcode】-代码随想录算法训练营Day15｜二叉树的层序遍历（附代码模版与相关习题/答案），226.翻转二叉树，101. 对称二叉树

于 2022-11-08 17:30:31 发布
阅读量147 收藏
点赞数
分类专栏： Leetcode-代码随想录 文章标签： 算法 leetcode 深度优先 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45364118/article/details/127751462
版权

二叉树的层序遍历

由于二叉树的特性，每个节点既可以作为其上层节点的孩子节点，也可以作为下层节点的父节点，所以与深度优先遍历一样，层序遍历可以使用递归法来实现。
同时，因为二叉树可以使用栈来进行深度优先的迭代遍历，那么作为广度优先的层序遍历，也可以使用队列来进行广度优先的迭代遍历。
二叉树的层序遍历思路也较为清晰明了，跟着代码过一遍即容易理解，同时利用二叉树层序遍历的题目，也能够轻松解决，因为此类题目的本质都是一样的，只需替换逻辑操作的模块即可。

Leetcode题目-102. Binary Tree Level Order Traversal

链接: 102. Binary Tree Level Order Traversal

代码实现

1. 递归法

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        leverOrderRec(root, 0, result);
        return result;
    }

    public void leverOrderRec(TreeNode root, int depth, List<List<Integer>> result) {
        if (root == null) {
            return;
        }

        if (result.size() == depth) {
            result.add(new ArrayList<>());
        }
        result.get(depth).add(root.val);
        leverOrderRec(root.left, depth + 1, result);
        leverOrderRec(root.right, depth + 1, result);
    }
}

2. 迭代法

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

层序遍历模版

分析一下上面的迭代法代码，可以比较容易理解思路。与层序遍历有关的题目，通常的变换是对二叉树的操作，计算的结果不同，在此类题目中，我们可以通过变更上述代码中的一些逻辑操作来实现，几乎等同于“套模版”的答题法。
模版可以参考以下代码：

class Solution {
    public ? levelOrder(TreeNode root) {
        // 根据题目要求初始化返回值等操作
        // ? result = new ?();
        Queue<TreeNode> queue = new ArrayDeque<>();
       
        if (root == null) {
            // 空情况处理
        }
        queue.offer(root);
        while (!queue.isEmpty()) {
            int len = queue.size();
            for (int i = 0; i < len; i++) {
                /* 
                进行一些题目要求的逻辑操作
                */
                // 把遍历完的节点的左右子节点插入
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            /* 
                进行一些题目要求的逻辑操作
            */
        }
        // 返回值
        return result;
    }
}

相关题目&解答代码

107.二叉树的层次遍历II

链接: 107. Binary Tree Level Order Traversal II

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

199.二叉树的右视图

链接: 199. Binary Tree Right Side View

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        Queue<TreeNode> queue = new ArrayDeque<>();
        if (root != null) {
            queue.offer(root);
        }

        while (!queue.isEmpty()) {
            int len = queue.size();
            TreeNode node = new TreeNode();
            for (int i = 0; i < len; i++) {
                node = queue.poll();
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            result.add(node.val);
        }
        return result;
    }
}

637.二叉树的层平均值

链接: 637. Average of Levels in Binary Tree

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> result = new ArrayList<>();
        Queue<TreeNode> queue = new ArrayDeque<>();
        if (root != null) {
            queue.offer(root);
        }

        while (!queue.isEmpty()) {
            int len = queue.size();
            TreeNode node = new TreeNode();
            double sum = 0;
            for (int i = 0; i < len; i++) {
                node = queue.poll();
                sum += node.val;
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            result.add(sum / len);
        }
        return result;
    }
}

429.N叉树的层序遍历

链接: 429. N-ary Tree Level Order Traversal

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> result = new ArrayList<>();
        Queue<Node> queue = new ArrayDeque<>();
        if (root != null) {
            queue.offer(root);
        }

        while (!queue.isEmpty()) {
            int len = queue.size();
            List<Integer> levelResult = new ArrayList<>();
            for (int i = 0; i < len; i++) {
                Node node = queue.poll();
                levelResult.add(node.val);
                for (Node children : node.children) {
                    queue.offer(children);
                }
            }
            result.add(levelResult);
        }
        return result;
    }
}

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

链接: 515. Find Largest Value in Each Tree Row

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        Queue<TreeNode> queue = new ArrayDeque<>();
        if (root != null) {
            queue.offer(root);
        }

        while (!queue.isEmpty()) {
            int len = queue.size();
            int levelMax = Integer.MIN_VALUE;
            for (int i = 0; i < len; i++) {
                TreeNode node = queue.poll();
                if (node.val > levelMax) {
                    levelMax = node.val;
                }
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            result.add(levelMax);
        }
        return result;
    }
}

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

链接: 116. Populating Next Right Pointers in Each Node

class Solution {
    public Node connect(Node root) {
        Queue<Node> queue = new ArrayDeque<>();
        if (root != null) {
            queue.offer(root);
        }

        while (!queue.isEmpty()) {
            int len = queue.size();
            Node cur = null;
            for (int i = 0; i < len; i++) {
                if (i == 0) {
                    cur = queue.poll();
                }else {
                    cur.next = queue.poll();
                    cur = cur.next;
                }
                if (cur.left != null) {
                    queue.offer(cur.left);
                }
                if (cur.right != null) {
                    queue.offer(cur.right);
                }
            }
            cur.next = null;
        }
        return root;
    }
}

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

链接: 117. Populating Next Right Pointers in Each Node II

class Solution {
    public Node connect(Node root) {
        Queue<Node> queue = new ArrayDeque<>();
        if (root != null) {
            queue.offer(root);
        }

        while (!queue.isEmpty()) {
            int len = queue.size();
            Node cur = null;
            for (int i = 0; i < len; i++) {
                if (i == 0) {
                    cur = queue.poll();
                } else {
                    cur.next = queue.poll();
                    cur = cur.next;
                }
                if (cur.left != null) {
                    queue.offer(cur.left);
                }
                if (cur.right != null) {
                    queue.offer(cur.right);
                }
            }
            cur.next = null;
        }
        return root;
    }
}

104.二叉树的最大深度

链接: 104. Maximum Depth of Binary Tree

class Solution {
    public int maxDepth(TreeNode root) {
        int maxDepth = 0;
        Queue<TreeNode> queue = new ArrayDeque<>();
        if (root != null) {
            queue.offer(root);
        }

        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            maxDepth++;
        }
        return maxDepth;
    }
}

111.二叉树的最小深度

链接: 1111. Minimum Depth of Binary Tree

class Solution {
    public int minDepth(TreeNode root) {
        int minDepth = 0;
        Queue<TreeNode> queue = new ArrayDeque<>();
        if (root != null) {
            queue.offer(root);
        }

        while (!queue.isEmpty()) {
            int size = queue.size();
            minDepth++;
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.left == null && node.right == null) {
                    return minDepth;
                }
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }

        }
        return minDepth;
    }
}

翻转二叉树

Leetcode题目-226. Invert Binary Tree

链接: 226. Invert Binary Tree

思路

翻转二叉树是指整个树以中间分割线进行翻转，其实就是将节点的左右子树互换。结合之前对二叉树遍历的了解，可以得出我们边遍历边互换就可以了，但是需要注意，要明确自己所用的遍历方法的原理，这样才能明白，左右子树互换的操作要在何时进行。例如在中序遍历中，如果采用迭代遍历，节点有可能会被两次访问，从而造成两次互换。此种情况下，选择前序遍历/后序遍历、层序遍历、统一迭代遍历（前中后序皆可）都是比较合适的。递归作为二叉树题目的重要解法，也适用。

代码实现

1. 递归法

递归法的书写过程中，依旧遵照并注意三个要点：递归函数的确定（入参，返回值），递归终止条件的确定，单层递归的逻辑。

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

    public TreeNode swapLeftAndRight(TreeNode root) {
        if (root==null) {
            return null;
        }

        TreeNode node = root.left;
        root.left = swapLeftAndRight(root.right);
        root.right = swapLeftAndRight(node);
        return root;
    }
}

2. 迭代法

  1. 普通迭代（前序遍历）
class Solution {
    public TreeNode invertTree(TreeNode root) {
        // 迭代法：前序遍历
        Deque<TreeNode> stack = new ArrayDeque<>();
        if (root != null) {
            stack.push(root);
        }

        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            TreeNode tmp = node.left;
            node.left = node.right;
            node.right = tmp;
            if (node.left != null) {
                stack.push(node.left);
            }
            if (node.right != null) {
                stack.push(node.right);
            }
        }
        return root;
    }
}
  1. 统一迭代（前序遍历）
class Solution {
    public TreeNode invertTree(TreeNode root) {
        // 统一迭代法：前序遍历
        Deque<TreeNode> stack = new LinkedList<>();
        if (root != null) {
            stack.push(root);
        }

        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            if (node != null) {
                if (node.right != null) {
                    stack.push(node.right);
                }
                if (node.left != null) {
                    stack.push(node.left);
                }
                stack.push(node);
                stack.push(null);
            } else {
                node = stack.pop();
                TreeNode tmp = node.left;
                node.left = node.right;
                node.right = tmp;
            }
        }
        return root;
    }
}
  1. 层序遍历迭代
class Solution {
    public TreeNode invertTree(TreeNode root) {
        // 层序遍历
        Queue<TreeNode> queue = new ArrayDeque<>();
        if (root != null) {
            queue.offer(root);
        }

        while (!queue.isEmpty()) {
            int levelSize = queue.size();
            for (int i = 0; i < levelSize; i++) {
                TreeNode node = queue.poll();
                TreeNode tmp = node.left;
                node.left = node.right;
                node.right = tmp;
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
        }
        return root;
    }
}

对称二叉树

Leetcode题目-226. Invert Binary Tree

链接: 226. Invert Binary Tree

思路

对称二叉树，需要弄明白的是我们如何判断比较左右子树，从而判断它是不是一个对称二叉树。如图可看出，它并不是节点的左右子树相等，而是左右节点的外侧节点和内侧节点相等。同样此题也可以使用迭代和递归两种方法来求解。
对称二叉树

代码实现

1. 递归法

递归法的三个步骤：

  1. 递归的函数（入参、出参）：输入父节点的左右两个子树，比较两个子树的内外侧，返回一个比较结果bool值

  2. 递归结束的条件：这里有多种情况，主要与左右子节点是否为空和是否符合对称有关，如下：

    • 左右节点都为空：父节点为叶子结点，父节点对称，返回true；
    • 左节点为空而右节点不为空或左节点不为空而右节点为空：此时父节点肯定不对称，返回false；
    • 左右节点均不为空，但是左右节点值不相同，那么也不对称，返回false；

  3. 单层递归的逻辑：除了上述需要结束的条件，剩下可能对称需要继续判断的情况就是：左右节点均不为空且左右节点值相同；此时进行递归，逻辑就是，比较左右子树的外侧和内侧是否相等，只要有一侧结果不相等，则对称不成立。

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }

        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;
        }

        return compare(left.left, right.right) && compare(left.right, right.left);
    }
}

2. 迭代法

迭代法中，主要的思路其实与递归法类似，但是这里用一个队列来暂存需要比较的两个节点，每次迭代中，从队列取出两个元素进行比较，并将其内外侧的孩子节点放入下一轮比较中，直到比较结束或提前中断。

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root.left);
        queue.offer(root.right);

        while (!queue.isEmpty()) {
            TreeNode left = queue.poll();
            TreeNode right = queue.poll();
            if (left == null && right == null) {
                continue;
            }

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

            queue.offer(left.left);
            queue.offer(right.right);
            queue.offer(left.right);
            queue.offer(right.left);
        }
        return true;
    }
}
大兔砸
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值