代码随想录算法训练营day15||二叉树part02、102.二叉树的层序遍历、 226.翻转二叉树（优先掌握递归）、101. 对称二叉树（优先掌握递归）

轻舟未过万重山ing

已于 2024-02-17 19:46:52 修改

阅读量824

点赞数 26

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

于 2024-02-09 17:16:35 首次发布

本文链接：https://blog.csdn.net/qq_40222433/article/details/136086077

版权

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

34 篇文章 0 订阅

订阅专栏

102.二叉树的层序遍历

题目：给你一个二叉树，请你返回其按层序遍历得到的节点值。（即逐层地，从左到右访问所有节点）。

接下来我们再来介绍二叉树的另一种遍历方式：层序遍历。

层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。

需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。

使用队列实现二叉树广度优先遍历，动画如下：

class Solution {
    //定义了一个名为resList 的成员变量，类型为List<List<Integer>>，用于存储层序遍历结果。
    //这个成员变量是一个二维列表，每个元素是一个!列表!，表示二叉树的一层节点值。
    public List<List<Integer>> resList = new ArrayList<List<Integer>>();

    //定义了一个名为levelOrder的公共方法，该方法接受一个TreeNode类型的参数root，表示二叉树的根节点。
    //该方法的返回类型是List<List<Integer>>，表示二叉树的层序遍历结果。
    public List<List<Integer>> levelOrder(TreeNode root) {
        checkFun02(root);//调用checkFun02 方法进行层序遍历。
        return resList;
    }

    //定义了一个名为checkFun02 的方法，用于实现二叉树的层序遍历。
    //首先检查当前节点node 是否为空，如果为空，则直接返回，表示无需进行层序遍历。
    public void checkFun02(TreeNode root){
        if(root == null) return;

        //创建一个名为que的队列，用于存储待访问的节点，并将根节点root入队列。
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        que.offer(root);//offer()：将元素添加到队尾，如果成功，则返回true。
        
        //使用循环来遍历队列中的节点，直到队列为空为止。
        while(!que.isEmpty()){
            //在内层循环中，首先创建一个名为itemList的列表，用于存储当前层的节点值，
            //并获取当前队列的大小，表示当前层的节点个数。
            List<Integer> itemList = new ArrayList<Integer>();
            int len = que.size();
            //这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            while(len > 0){
              //从队列中弹出一个节点tmpNode，并将其值添加到当前层的列表itemList中。
                TreeNode tmpNode = que.poll();//poll()：将队首的元素删除，并返回该元素。
                itemList.add(tmpNode.val); 
                if(tmpNode.left != null)  que.offer(tmpNode.left);
                if(tmpNode.right != null)  que.offer(tmpNode.right);
                len--;
            }
            //当前层的所有节点都处理完毕后，将当前层的列表itemList添加到结果列表resList中，并进入下一层的处理。
            resList.add(itemList);
        }
       
    }
    //至此，二叉树的层序遍历完成，结果存储在成员变量resList中，返回给调用者。
}

107.二叉树的层次遍历 II

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

思路：相对于102.二叉树的层序遍历，就是最后把result数组反转一下就可以了。

class Solution {
    public List<List<Integer>> resList = new ArrayList<List<Integer>>();

    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        //checkFun01(root,0);
        checkFun02(root);

        //创建一个新的二维列表 result，用于存储按自底向上顺序排列的层序遍历结果。
        List<List<Integer>> result = new ArrayList<>();
        //使用循环遍历原始的层序遍历结果 resList，从最后一层开始，逐层向上遍历。
        //在遍历过程中，将每一层的节点列表添加到 result 中。
        for (int i = resList.size() - 1; i >= 0; i-- ) {
            result.add(resList.get(i));
        }
        return result;//返回按自底向上顺序排列的层序遍历结果列表 result。
    }
 public void checkFun02(TreeNode node) {
        if (node == null) return;
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        que.offer(node);

        while (!que.isEmpty()) {
            List<Integer> itemList = new ArrayList<Integer>();
            int len = que.size();

            while (len > 0) {
                TreeNode tmpNode = que.poll();
                itemList.add(tmpNode.val);

                if (tmpNode.left != null) que.offer(tmpNode.left);
                if (tmpNode.right != null) que.offer(tmpNode.right);
                len--;
            }

            resList.add(itemList);
        }

    }
}

在102基础上稍作改动：

//创建一个新的二维列表 result，用于存储按自底向上顺序排列的层序遍历结果。

List<List<Integer>> result = new ArrayList<>();

//使用循环遍历原始的层序遍历结果 resList，从最后一层开始，逐层向上遍历。

//在遍历过程中，将每一层的节点列表添加到 result 中。

for (int i = resList.size() - 1; i >= 0; i-- ) {

result.add(resList.get(i));

}

return result; //返回按自底向上顺序排列的层序遍历结果列表 result。

199.二叉树的右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

思路：层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。

class Solution {
    /**
     * 解法：队列，迭代。
     * 每次返回每层的最后一个字段即可。
     * 小优化：每层右孩子先入队。代码略。
     */
     public List<Integer> rightSideView(TreeNode root) {
//定义了一个名为rightSideView的公共方法，该方法接受一个TreeNode类型的参数root，表示二叉树的根节点。
//该方法的返回类型是List<Integer>，表示二叉树每层最右侧节点的值。

        //创建一个名为 resList 的列表，用于存储每层最右侧节点的值。
        List<Integer> resList = new ArrayList<>();
        //创建一个名为 que 的双端队列，用于进行层序遍历。
        //这里选择双端队列的原因是为了让每层的右孩子先入队，以便后续直接取出最后一个节点。
        Deque<TreeNode> que = new LinkedList<>();
    
        //如果根节点为空，则直接返回空列表。
        if (root == null) {
            return resList;
        }
        //将根节点入队。
        que.offerLast(root);
        //使用循环遍历队列中的节点，直到队列为空为止。
         while (!que.isEmpty()) {
            //获取当前层的节点数levelSize，并使用内层循环遍历当前层的所有节点。
            int levelSize = que.size();
            //从队列中弹出一个节点tmpNode，并将其左右孩子节点依次入队。
            for (int i = 0; i < levelSize; i++) {
                TreeNode tmpNode = que.pollFirst();

                if (tmpNode.left != null) {
                    que.addLast(tmpNode.left);
                }
                if (tmpNode.right != null) {
                    que.addLast(tmpNode.right);
                }
                //如果当前节点是当前层的最后一个节点，则将其值添加到结果列表resList中。
                if (i == levelSize - 1) {
                    resList.add(tmpNode.val);
                } 
                //继续处理下一层的节点。
            }
        }
        return resList;//返回存储了每层最右侧节点值的列表resList。
    }
}

637.二叉树的层平均值

给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。

思路：本题就是层序遍历的时候把一层求个总和在取一个均值。

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        //定义了一个名为averageOfLevels 的公共方法，该方法接受一个TreeNode类型的参数root，表示二叉树的根节点。
        //该方法的返回类型是List<Double>，表示二叉树每层节点值的平均值。

        //创建一个名为resList的列表，用于存储每层节点值的平均值。
        List<Double> resList = new ArrayList<>();
        //创建一个名为 que 的双端队列，用于进行层序遍历。
        Deque<TreeNode> que = new LinkedList<>();

        if(root == null){
            return resList;
        }
        //将根节点入队。
        que.offerLast(root);
        //使用循环遍历队列中的节点，直到队列为空为止。
        while(!que.isEmpty()){
            //获取当前层的节点数levelSize，并使用内层循环遍历当前层的所有节点。
            int levelSize = que.size();
            double levelSum = 0.0;
            for(int i = 0; i < levelSize; i++){
                //从队列中弹出一个节点poll，并将其值加到当前层的和levelSum 中。
                TreeNode tmpNode = que.pollFirst();
                levelSum += tmpNode.val;
                //然后将其左右孩子节点依次入队。
                if(tmpNode.left != null) que.addLast(tmpNode.left);
                if(tmpNode.right != null) que.addLast(tmpNode.right);
        }
        resList.add(levelSum / levelSize);//计算当前层节点值的平均值，并将其添加到结果列表resList中。
    }
    return resList;//返回存储了每层节点值平均值的列表list。
    }
}

429.N叉树的层序遍历

给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。

思路：这道题依旧是模板题，只不过一个节点有多个孩子了

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

您需要在二叉树的每一行中找到最大的值。

思路：层序遍历，取每一层的最大值

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

给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

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

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

思路：这道题目说是二叉树，但116题目说是完整二叉树，其实没有任何差别，一样的代码一样的逻辑一样的味道

2104.二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：给定二叉树 [3,9,20,null,null,15,7]，

111.二叉树的最小深度

思路：相对于 104.二叉树的最大深度，本题还也可以使用层序遍历的方式来解决，思路是一样的。需要注意的是，只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点

总结：

二叉树的层序遍历，就是图论中的广度优先搜索在二叉树中的应用，需要借助队列来实现（此时又发现队列的一个应用了）。

来吧，一口气打十个：

226.翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

题外话：这道题目是非常经典的题目，也是比较简单的题目（至少一看就会）。

但正是因为这道题太简单，一看就会，一些同学都没有抓住起本质，稀里糊涂的就把这道题目过了。如果做过这道题的同学也建议认真看完，相信一定有所收获！

注意只要把每一个节点的左右孩子翻转一下，就可以达到整体翻转的效果

这道题目使用前序遍历和后序遍历都可以，唯独中序遍历不方便，因为中序遍历会把某些节点的左右孩子翻转了两次！建议拿纸画一画，就理解了

那么层序遍历可以不可以呢？依然可以的！只要把每一个节点的左右孩子翻转一下的遍历方式都是可以的！

递归法：

class Solution {
    //递归法
/** 前后序遍历都可以
    （这里代码给出的后序遍历，先递归处理左子树，然后递归处理右子树，最后再处理根节点。）
  * 中序不行，因为先左孩子交换孩子，再根交换孩子（做完后，右孩子已经变成了原来的左孩子），
    再右孩子交换孩子（此时其实是对原来的左孩子做交换）
*/
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {//递归终止条件
            return root;
        }
        //递归地对当前节点的左右子树进行反转，即先对左子树进行反转，再对右子树进行反转。
        invertTree(root.left);
        invertTree(root.right);
        swapChildren(root); //调用swapChildren 方法交换当前节点的左右子节点。

        return root;//返回反转后的二叉树的根节点。
    } 
    //定义了一个私有方法swapChildren，用于交换节点的左右子节点。
    //这个方法接受一个节点root，将其左右子节点进行交换
    private void swapChildren(TreeNode root){
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;
    }
}

101. 对称二叉树（优先掌握递归）

给定一个二叉树，检查它是否是镜像对称的。

首先想清楚，判断对称二叉树要比较的是哪两个节点，要比较的可不是左右节点！

对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。

那么如何比较呢？

比较的是两个子树的里侧和外侧的元素是否相等。如图所示：

那么遍历的顺序应该是什么样的呢？

本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。

正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。

但都可以理解算是后序遍历，尽管已经不是严格上在一个树上进行遍历的后序遍历了。

其实后序也可以理解为是一种回溯，当然这是题外话，讲回溯的时候会重点讲的。

递归法

递归三部曲

确定递归函数的参数和返回值

因为我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。

返回值自然是bool类型。

代码如下：

bool compare(TreeNode* left, TreeNode* right)

2.确定终止条件

要比较两个节点数值相不相同，首先要把两个节点为空的情况弄清楚！否则后面比较数值的时候就会操作空指针了。

节点为空的情况有：（注意我们比较的其实不是左孩子和右孩子，所以如下我称之为左节点右节点）

左节点为空，右节点不为空，不对称，return false
左不为空，右为空，不对称 return false
左右都为空，对称，返回true

此时已经排除掉了节点为空的情况，那么剩下的就是左右节点不为空：

左右都不为空，比较节点数值，不相同就return false

此时左右节点不为空，且数值也不相同的情况我们也处理了。

代码如下：

if (left == NULL && right != NULL) return false;
else if (left != NULL && right == NULL) return false;
else if (left == NULL && right == NULL) return true;
else if (left->val != right->val) return false; // 注意这里我没有使用else

注意上面最后一种情况，我没有使用else，而是else if，因为我们把以上情况都排除之后，剩下的就是左右节点都不为空，且数值相同的情况。

3.确定单层递归的逻辑

此时才进入单层递归的逻辑，单层递归的逻辑就是处理左右节点都不为空，且数值相同的情况。

比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
比较内侧是否对称，传入左节点的右孩子，右节点的左孩子。
如果左右都对称就返回true ，有一侧不对称就返回false 。

代码如下：

bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
bool isSame = outside && inside;                    // 左子树：中、 右子树：中（逻辑处理）
return isSame;

如上代码中，我们可以看出使用的遍历方式，左子树左右中，右子树右左中，所以我把这个遍历顺序也称之为“后序遍历”（尽管不是严格的后序遍历）。

我给出的代码并不简洁，但是把每一步判断的逻辑都清楚的描绘出来了。

如果上来就看网上各种简洁的代码，看起来真的很简单，但是很多逻辑都掩盖掉了，而题解可能也没有把掩盖掉的逻辑说清楚。

盲目的照着抄，结果就是：发现这是一道“简单题”，稀里糊涂的就过了，但是真正的每一步判断逻辑未必想到清楚。

（代码随想录参考精简版本）

class Solution {
    public boolean isSymmetric(TreeNode root) {
        //递归法
        return compare(root.left,root.right);//返回调用compare方法时左右子树作为参数的结果。
    }

    private boolean compare(TreeNode left,TreeNode right){
        //确定终止条件（节点为空的几种情况）
        //①左节点为空，右节点不为空，不对称，return false
        if (left == null && right != null) {
            return false;
        }
        //②左不为空，右为空，不对称 return false
        if (left != null && right == null) {
            return false;
        }
        //③左右都为空，对称，返回true
        if (left == null && right == null) {
            return true;
        }
        //④左右都不为空，比较节点数值，不相同就return false
        if (left.val != right.val) {
            return false;
        }

        //调用递归方法，比较根的子树的外侧
        boolean compareOutside = compare(left.left,right.right);
        //调用递归方法，比较根的子树的内侧
        boolean compareInside = compare(left.right,right.left);
        return compareOutside && compareInside;//都为true，则返回true，表示子树的外侧和内侧都对称。否则，返回false。
    }
}

100.相同的树

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        //递归法
        return compare(p,q);
    }
    //定义递归方法compare，用于比较左右子树是否相等
    private boolean compare(TreeNode p,TreeNode q){
         // 如果两棵树都为空，则它们相同
        if (p == null && q == null) {
            return true;
        }
        // 如果其中一棵树为空，另一棵不为空，则它们不相同
        if (p == null || q == null) {
            return false;
        }
        // 如果两个节点的值不相等，则它们不相同
        if (p.val != q.val) {
            return false;
        }
        // 递归地比较左子树和右子树
        boolean compareOutside = compare(p.left,q.left);
        boolean compareInside = compare(p.right,q.right);
        return compareOutside && compareInside;
        //return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
    }
}

也可以不构造compare方法，直接将递归合并到 return语句中！（简洁，高级!）

class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        // 如果两棵树都为空，则它们相同
        if (p == null && q == null) {
            return true;
        }
        // 如果其中一棵树为空，另一棵不为空，则它们不相同
        if (p == null || q == null) {
            return false;
        }
        // 如果两个节点的值不相等，则它们不相同
        if (p.val != q.val) {
            return false;
        }
        // 递归地比较左子树和右子树
        return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
    }
}

572.另一个树的子树

给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

class Solution {
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        //递归法
        if (root == null) {
            return false;
        }
        if (compare(root, subRoot)) {
            return true;
        }
        return compare(root.left,subRoot) || compare(root.right,subRoot);
    }

    //定义递归方法compare，用于比较左右子树是否相等
    private boolean compare(TreeNode p,TreeNode q){
         // 如果两棵树都为空，则它们相同
        if (p == null && q == null) {
            return true;
        }
        // 如果其中一棵树为空，另一棵不为空，则它们不相同
        if (p == null || q == null) {
            return false;
        }
        // 如果两个节点的值不相等，则它们不相同
        if (p.val != q.val) {
            return false;
        }
        // 最后，递归地检查两棵树的左子树和右子树是否相同。
        boolean compareOutside = compare(p.left,q.left);
        boolean compareInside = compare(p.right,q.right);
        return compareOutside && compareInside;
        //return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
    }
}

在这段代码中，isSubtree 方法用于检查是否存在与给定子树相同的子树。它首先检查根节点是否为空，如果为空，则返回 false。然后，它调用compare 方法来检查当前节点和子树根节点是否相同。如果相同，说明找到了子树，直接返回 true。如果不相同，则递归地检查左子树和右子树是否包含相同的子树。
compare方法用于检查两棵树是否相同，它采用了递归的方式。

首先，检查两棵树的根节点是否都为空，如果都为空，则返回 true。

然后，检查其中一个根节点是否为空，如果一个为空而另一个不为空，则返回 false。

接着，比较两个根节点的值是否相同，如果不相同，则返回 false。

最后，递归地检查两棵树的左子树和右子树是否相同。

提交发现以上代码没有AC：以下测试用例未通过：（110/182）

class Solution {
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        // 递归法
        if (subRoot == null) return true;//subRoot为null一定都是true，空是任何二叉树的子树
        if (root == null) return false;//这里subRoot一定不为null, 只要root为null，肯定是false
        return isSameTree(root, subRoot) || isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot);
    }

    //定义递归方法，判断两棵树是否相同
    private boolean isSameTree(TreeNode p, TreeNode q) {
        if (p == null && q == null) return true;
        if (p == null || q == null) return false;
        if (p.val != q.val) return false;
        //最后，递归地检查两棵树的左子树和右子树是否相同。
        // boolean compareOutside = compare(p.left,q.left);
        // boolean compareInside = compare(p.right,q.right);
        // return compareOutside && compareInside;
        return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
    }
}

轻舟未过万重山ing

关注

26
点赞
踩
13

收藏

觉得还不错? 一键收藏
1
评论
代码随想录算法训练营day15||二叉树part02、102.二叉树的层序遍历、 226.翻转二叉树（优先掌握递归）、101. 对称二叉树（优先掌握递归）

二叉树的层序遍历，就是图论中的广度优先搜索在二叉树中的应用，需要借助队列来实现（此时又发现队列的一个应用了）。102.二叉树的层序遍历(opens new window)107.二叉树的层次遍历II(opens new window)199.二叉树的右视图(opens new window)637.二叉树的层平均值(opens new window)429.N叉树的层序遍历(opens new window)515.在每个树行中找最大值(opens new window)
复制链接

扫一扫