文章讲述了如何使用Java实现二叉树的层序遍历，包括常规的顺序和倒序输出，以及二叉树的右视图和翻转二叉树的操作，还涉及到了对称二叉树的判断方法。
层序遍历 10
这一节有十道题目，我只看了前三道
题目
文章讲解
视频讲解
思路：层序遍历，利用队列实现，注意数列和队列，还有各个部分数据结构的设置关系，现在有点绕，打算后面再看看
/**
* 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>> resList = new ArrayList<List<Integer>>();
public List<List<Integer>> levelOrder(TreeNode root) {
checkFun02(root);
return resList;
}
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);
}
}
}
```java
class Solution {
public List<List<Integer>> levelOrderBottom(TreeNode root) {
List<List<Integer>> list =new ArrayList<>(); // 创建一个列表来存储层次遍历的结果
Deque<TreeNode> que = new LinkedList<>(); // 创建一个队列来执行层次遍历
if(root==null) return list; // 如果根节点为空，返回空列表
que.offer(root); // 将根节点加入队列
while(!que.isEmpty()){ // 执行层次遍历
List<Integer> levelList=new ArrayList<>(); // 创建一个列表来存储当前层的节点值
int len=que.size();
for(int i=0;i<len;i++){
TreeNode tmpNode=que.poll(); // 取出队首元素
levelList.add(tmpNode.val); // 将节点值加入当前层的列表
if(tmpNode.left!=null) que.offer(tmpNode.left); // 如果左子节点不为空，加入队列
if(tmpNode.right!=null) que.offer(tmpNode.right); // 如果右子节点不为空，加入队列
}
list.add(levelList); // 将当前层的列表加入结果列表
}
List<List<Integer>> result=new ArrayList<>(); // 创建一个新的列表来存储倒序的层次遍历结果
for(int i=list.size()-1;i>=0;i--){
result.add(list.get(i)); // 将层次遍历结果倒序加入新的列表
}
return result; // 返回倒序的层次遍历结果
}
}
```java
class Solution {
public List<List<Integer>> levelOrderBottom(TreeNode root) {
List<List<Integer>> result = new ArrayList<>(); // 用于存储最终结果的列表
if (root == null) {
return result; // 如果根节点为空，直接返回空列表
}
Deque<TreeNode> queue = new LinkedList<>(); // 创建一个队列来执行层次遍历
queue.offer(root); // 将根节点加入队列
while (!queue.isEmpty()) { // 执行层次遍历
List<Integer> levelList = new ArrayList<>(); // 用于存储当前层节点值的列表
int levelSize = queue.size(); // 记录当前层的节点数
for (int i = 0; i < levelSize; i++) {
TreeNode currentNode = queue.poll(); // 取出队首节点
levelList.add(currentNode.val); // 将节点值加入当前层的列表
if (currentNode.left != null) {
queue.offer(currentNode.left); // 如果左子节点不为空，加入队列
}
if (currentNode.right != null) {
queue.offer(currentNode.right); // 如果右子节点不为空，加入队列
}
}
result.add(0, levelList); // 将当前层的列表插入到结果列表的开头，实现倒序存储
}
return result; // 返回倒序的层次遍历结果
}
}
```java
class Solution {
public List<Integer> rightSideView(TreeNode root) {
List<Integer> list =new ArrayList<>(); // 创建一个列表来存储树的右侧视图
Deque<TreeNode> que=new LinkedList<>(); // 创建一个队列来执行层次遍历
if(root==null) return list; // 如果根节点为空，返回空列表
que.offerLast(root); // 将根节点加入队列
while(!que.isEmpty()){ // 执行层次遍历
int len=que.size();
for(int i=0;i<len;i++) {
TreeNode poll=que.pollFirst(); // 取出队首元素
if(poll.left!=null) que.addLast(poll.left); // 如果左子节点不为空，加入队列
if(poll.right!=null) que.addLast(poll.right); // 如果右子节点不为空，加入队列
if(i==len-1) list.add(poll.val); // 如果是当前层的最后一个节点，将节点的值加入列表
}
}
return list; // 返回包含树右侧视图的列表
}
}
226.翻转二叉树
- 需要注意的是交换的是结点的指针，不是值
- 前序后序都可以，中序比较绕，绕到最后会绕回去
//后序遍历
class Solution {
public TreeNode invertTree(TreeNode root) {
if(root==null) return null;
invertTree(root.left);
invertTree(root.right);
swapChildren(root);
return root;
}
private void swapChildren(TreeNode root){
TreeNode tmp=root.left;
root.left=root.right;
root.right=tmp;
}
}
101.对称二叉树 2
- 后序遍历：需要收集孩子信息向上一层返回
- 判断逻辑：
- 节点为空的情况有：（注意我们比较的其实不是左孩子和右孩子，所以如下我称之为左节点右节点）
- 左节点为空，右节点不为空，不对称，return false
- 左不为空，右为空，不对称 return false
- 左右都为空，对称，返回true
- 此时已经排除掉了节点为空的情况，那么剩下的就是左右节点不为空：
- 左右都不为空，比较节点数值，不相同就return false
/**
* 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) {
return compare(root.left,root.right);
}
private boolean compare(TreeNode left,TreeNode right){
if(left==null && right!=null) return false;
if(left!=null && right==null) return false;
if(left==null && right==null) return true;
if(left.val!=right.val) return false;
boolean compareOutside = compare(left.left,right.right);
boolean compareInside = compare(left.right,right.left);
return compareOutside && compareInside;
}
}
85
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
