代码随想录算法训练营第15天 | 二叉树层序遍历(8题)、226.翻转二叉树、101.对称二叉树

已于 2024-01-25 20:59:45 修改
阅读量617 收藏 12
点赞数 16
分类专栏： 代码随想录训练营 文章标签： 算法
于 2024-01-25 20:51:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1594425141/article/details/135853412
版权

@[TOC](代码随想录算法训练营第15天 | 二叉树层序遍历(8题)、226.翻转二叉树、101.对称二叉树)

二叉树层序遍历 有八道题

102.二叉树的层序遍历

题目：102.二叉树的层序遍历
文档讲解：代码随想录-102.二叉树的层序遍历
视频讲解：哔哩哔哩-102.二叉树的层序遍历
状态/时间：没写出来/三十分钟

思路：
利用队列跟BFS广度优先。
代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //BFS--迭代方式--借助队列
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            while (size-- > 0) {
                TreeNode node = queue.peek();
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
                list.add(queue.poll().val);
            }
            res.add(list);
        }
        return res;
    }
}

注意：

2.二叉树的层次遍历 II 107

思路

直接插入到头部，这样可以不用反转，插入是O(1)

代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            while (size-- > 0) {
                TreeNode node =queue.peek();queue.poll();
                list.add(node.val);
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
                
            }
            // 插入到头部，这样不用反转O(1)
            res.addFirst(list);
        }
        return res;
    }
}
3. 二叉树的右视图 199

思路：

其实就是每层的最后一个结点，记录下来就好了。

代码：

// /**
//  * Definition for a binary tree node.
//  * public class TreeNode {
//  *     int val;
//  *     TreeNode left;
//  *     TreeNode right;
//  *     TreeNode() {}
//  *     TreeNode(int val) { this.val = val; }
//  *     TreeNode(int val, TreeNode left, TreeNode right) {
//  *         this.val = val;
//  *         this.left = left;
//  *         this.right = right;
//  *     }
//  * }
//  */
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }
        Deque<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offerLast(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.pollFirst();

                if (node.left != null) {
                    queue.add(node.left);
                }

                if (node.right != null) {
                    queue.add(node.right);
                }
                if (i == size - 1) {
                    res.add(node.val);
                }
            }
        }
        return res;
    }
}

注意：

4. 637.二叉树的层平均值 637

思路：

只需要计算平均值即可，我这里有点笨。第二个while应该用for比较好。

代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> res = new ArrayList<Double>();
        if (root == null) {
            return res;
        }
        Deque<TreeNode> deque = new LinkedList<TreeNode>();
        deque.add(root);
        while (!deque.isEmpty()) {
            double avg = 0.0;
            int size = deque.size();
            int size1 = deque.size();
            while (size-- > 0) {
                TreeNode node = deque.poll();
                avg += node.val;
                if (node.left != null) {
                    deque.add(node.left);
                }
                if (node.right != null) {
                    deque.add(node.right);
                }
            }
            res.add(avg / size1);
        }
        return res;
    }
}

注意：

5. N叉树的层序遍历 429

思路：

把判断左右子树的操作改为遍历所有子树

代码：

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }

        Deque<Node> deque = new LinkedList<Node>();
        deque.add(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                Node node = deque.poll();
                list.add(node.val);
                if (node.children != null) {
                    for (Node child : node.children) {
                        deque.add(child);
                    }
                }
            }
            res.add(list);
        }
        return res;
    }
}

注意：

6. 在每个树行中找最大值 116

思路：

找到最大的值，添加到res里面即可

代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }
        Deque<TreeNode> deque = new LinkedList<TreeNode>();
        deque.add(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            int temp = Integer.MIN_VALUE;
            while (size-- > 0) {
                TreeNode node = deque.poll();
                if (node.val > temp) {
                    temp = node.val;
                }
                if (node.left != null) {
                    deque.add(node.left);
                }
                if (node.right != null) {
                    deque.add(node.right);
                } 
            }
            res.add(temp);
        }
        return res;
    }
}

注意：

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

思路：

思路还不是很清晰

代码：

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        if (root == null) {
            return root;
        }

        Deque<Node> deque = new LinkedList<Node>();
        deque.add(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            Node cur = deque.poll();
            if (cur.left != null) {
                deque.add(cur.left);
            }
            if (cur.right != null) {
                deque.add(cur.right);
            }

            for (int i = 1; i < size; i++) {
                Node next = deque.poll();
		        if (next.left != null) deque.add(next.left);
		        if (next.right != null) deque.add(next.right);
                cur.next = next;
                cur = next;
            }
        }
        return root;
    }
}

注意：

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

思路：

思路还不是很清晰

代码：

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        if (root == null) {
            return root;
        }

        Deque<Node> deque = new LinkedList<Node>();
        deque.add(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            Node cur = deque.poll();
            if (cur.left != null) {
                deque.add(cur.left);
            }
            if (cur.right != null) {
                deque.add(cur.right);
            }

            for (int i = 1; i < size; i++) {
                Node next = deque.poll();
		        if (next.left != null) deque.add(next.left);
		        if (next.right != null) deque.add(next.right);
                cur.next = next;
                cur = next;
            }
        }
        return root;
    }
}

注意：

226.翻转二叉树

题目：226.翻转二叉树
文档讲解：代码随想录-226.翻转二叉树
视频讲解：哔哩哔哩-226.翻转二叉树
状态/时间：没写出来/三十分钟

思路：
定义一个swap方法，通过左换右，右换左，再递归调用即可实现反转二叉树。

代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }
        // 前序的方式
        swap(root);
        invertTree(root.left);
        invertTree(root.right);
        return root;

    }
    public void swap(TreeNode root) {
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }
}

注意：

101.对称二叉树

题目：101.对称二叉树
文档讲解：代码随想录-101.对称二叉树
视频讲解：哔哩哔哩-101.对称二叉树
状态/时间：没写出来/三十分钟

思路：
判断二叉树的子树的内测和外侧是否相等，只有两个相等才能是对称。同时也要考虑子树是否，左有子树，右没有子树。右有子树，左没有子树的情况。

以及他们的值是否相等，最后还有两边子树都为空的情况。

代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) return false;
        return compare(root.left, root.right);
    }
    public boolean compare(TreeNode left, TreeNode right) {
        // 左 不等于 右
        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;
        }
	    // 外侧
        boolean outside = compare(left.left, right.right);
        // 内测
        boolean inside = compare(left.right, right.left);
        // 要两个都相等
        boolean result = outside && inside;
        return result;
    }
}

注意：

a零点妖孽
关注
  • 16
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的遍历二叉树的遍历二叉树的遍历二叉树的遍历.txt
05-20
二叉树的遍历二叉树的遍历二叉树的遍历二叉树的遍历二叉树的遍历
二叉树的创建与遍历C语言实现代码.zip
05-27
二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言...
8606-二叉树的构建及遍历操作.rar_二叉树_遍历算法
09-21
用户可以通过阅读代码了解二叉树的构建方法和遍历算法的具体实现细节，也可以直接运行代码进行测试，加深对二叉树的理解。同时，这是一个很好的实践项目，可以帮助初学者巩固数据结构基础，提高编程技能。 总结来说...
python-leetcode面试题解之第102题二叉树的层序遍历-题解.zip
04-29
本题解将详细探讨Python实现的LeetCode第102题——二叉树的层序遍历。层序遍历，也称为广度优先搜索（BFS），是处理二叉树问题的一种常见策略。 **二叉树的概念** 二叉树是一种特殊的图结构，每个节点最多有两个子...
二叉树的遍历以及创建.zip
04-30
二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的...
【18】输出字符菱形
2301_78786609的博客
07-19 185
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Held-Karp算法的C++代码
m0_61862494的博客
07-19 102
Held-Karp算法是动态规划的一种应用，用于解决旅行商问题 (TSP)。该算法通过记录部分路径的最小成本来避免重复计算，从而有效地降低计算复杂度。Held-Karp算法使用一个状态压缩动态规划表。表示从起点出发，访问过所有由。表示的集合中的节点，并以节点。结束的最小路径长度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 163
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
树与二叉树
2201_76027754的博客
07-15 790
树和二叉树
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 132
完全二叉树的节点个数-递归
【算法】算法模板
qq_44765647的博客
07-19 151
LeetCode网站中学习算法的过程中使用到并总结的算法模板算法模板 数组算法模板，字符串算法模板，列表算法模板，数学算法模板，树算法模板，图算法模板，动态规划算法模板
C语言习题~day32
最新发布
TU^的博客
07-19 234
第一次循环，i 从 7 减 3 变为 4，j 加 1 变为 1；第二次循环，i 变为 1，j 变为 2；第三次循环，i 变为 253（7 减 3 溢出后变为 253），j 加 1 变为 3；第四次循环，i 变为 250，j 加 1 变为 4；第五次循环，i 变为 247，j 加 1 变为 5；依次类推，直到 i 变为 0 时，循环结束。从 7 开始每次减 3，7、4、1、253、250、247……输入：[9,6,4,2,3,5,7,0,1]无符号字符型的取值范围是 0 到 255。输入：[3,0,1]
力扣第十八题——四数之和
m0_74932528的博客
07-19 293
该代码通过排序、剪枝和双指针法，有效地解决了四数之和问题，时间复杂度从暴力解法的 O(n^4) 降低到 O(n^3)。
拆分整数 java
laocooon的博客
07-16 666
输入: n = 10输出: 36解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。输入: n = 2输出: 1解释: 2 = 1 + 1, 1 × 1 = 1。），并使这些整数的乘积最大化。你可以获得的最大乘积。
算法刷题笔记 食物链（详细注释的C++实现）
hanmo22357的博客
07-16 418
一道较难理解的并查集算法题，给出了详细注释的C++代码实现
力扣第七题——整数反转
m0_74932528的博客
07-15 415
/ 方法体这里定义了一个名为Solution的类，以及一个reverse方法，该方法接收一个整数x作为参数，并返回一个整数。
前缀和算法——部分OJ题详解
aaqq800520的博客
07-17 974
（文章的题目解释可能存在一些问题，欢迎各位小伙伴私信或评论指点（双手合十））
面试题 27. 二叉树的镜像
weixin_51332735的博客
07-16 470
请完成一个函数，输入一个二叉树，该函数输出它的镜像。
代码随想录算法训练营第13天|二叉树
weixin_73795426的博客
07-15 381
1.打印前序遍历节点，参数传入ArrayList来存放结点数值，同时迭代的是每个节点，也无需返回值.顺序为中左右，当前结点值加入结果集，result.add(curNode..val)遍历右节点，preorder(curNode.right,result)遍历左结点，preorder（curNode.left,result)确定哪些参数递归过程需要处理——>递归函数中加上这个参数。明确递归的返回值是什么——>确定递归函数的返回类型。栈溢出错误就是没写终止条件或者终止条件写的错误。根据这个模板，前序遍历。
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例。该代码使用了递归法的前序遍历，对于每一个节点，交换其左右子节点，然后递归地对其左右子树进行翻转。 引用中给出了一个实现二叉树的层序遍历的代码示例。该代码使用了BFS的思想，借助队列来实现层序遍历。每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列，同时将当前层的节点值添加到结果列表中。 综上所述，参考这些引用，可以通过BFS来实现二叉树的层序遍历，并通过递归法或迭代法来翻转二叉树。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值