public class four {
}
//102.二叉树的层序遍历
class Solution {
public List<List<Integer>> resList = new ArrayList<List<Integer>>();
public List<List<Integer>> levelOrder(TreeNode root){
checkFun01(root, 0);
checkFun02(root);
return resList;
}
//DFS--递归方式
private void checkFun01(TreeNode node, int deep) {
if(node == null) {
return;
}
deep++;//即调用了checkFun01 就使层数deep+1
if (resList.size() < deep) {
//当层级增加时，list的Item也增加，利用list的索引值进行层级界定
List<Integer> item = new ArrayList<Integer>();
resList.add(item);
}
resList.get(deep - 1).add(node.val);//上面的item可不是白添加，这里的get就是吧item拿出来了
checkFun01(node.left, deep);
checkFun01(node.right, deep);
}
//BFS--迭代方式--借助队列
private 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);//例如root结点，其实这里可以看作将下一层的结点提前放入que中 然后继续外层的while循环
if (tmpNode.right != null) que.offer(tmpNode.right);
len--;//例如root结点，此时len=0 退出内层while循环
}
resList.add(itemList);
}
}
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;
}
}
}
package com.tree.java;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class five {
}
//102.二叉树的层序遍历
class Solution {
public List<List<Integer>> resList = new ArrayList<List<Integer>>();
public List<List<Integer>> levelOrder(TreeNode root){
checkFun01(root, 0);
// checkFun02(root);
Collections.reverse(resList);
return resList;
}
//DFS--递归方式
private void checkFun01(TreeNode node, int deep) {
if(node == null) {
return;
}
deep++;//即调用了checkFun01 就使层数deep+1
if (resList.size() < deep) {
//当层级增加时，list的Item也增加，利用list的索引值进行层级界定
List<Integer> item = new ArrayList<Integer>();
resList.add(item);
}
resList.get(deep - 1).add(node.val);//上面的item可不是白添加，这里的get就是吧item拿出来了
checkFun01(node.left, deep);
checkFun01(node.right, deep);
}
//BFS--迭代方式--借助队列
private 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);//例如root结点，其实这里可以看作将下一层的结点提前放入que中 然后继续外层的while循环
if (tmpNode.right != null) que.offer(tmpNode.right);
len--;//例如root结点，此时len=0 退出内层while循环
}
resList.add(itemList);
}
}
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;
}
}
}
public class six {
//BFS--迭代方式--借助队列
//199.二叉树的右视图
public List<Integer> rightSideView(TreeNode root) {
Queue<TreeNode> que = new LinkedList<TreeNode>();
List<Integer> itemList = new ArrayList<Integer>();//用来存放每一层的结点
que.offer(root);
if (root == null) {
return itemList;
}
while (!que.isEmpty()) {
int len = que.size();
for(int i = 0; i < len;i++) {
TreeNode tmpNode = que.poll();
if (tmpNode.left != null) que.offer(tmpNode.left);//例如root结点，其实这里可以看作将下一层的结点提前放入que中 然后继续外层的while循环
if (tmpNode.right != null) que.offer(tmpNode.right);
if(i == len - 1) {
itemList.add(tmpNode.val);
}
}
}
return itemList;
}
}
class Solution {
//BFS--迭代方式--借助队列
public List<Double> averageOfLevels(TreeNode root) {
Queue<TreeNode> que = new LinkedList<TreeNode>();
List<Double> itemList = new ArrayList<>();//用来存放每一层的结点
que.offer(root);
if (root == null) {
return itemList;
}
while (!que.isEmpty()) {
int len = que.size();
double levelSum = 0.0;
for (int i = 0; i < len; i++) {
TreeNode tmpNode = que.poll();
levelSum += tmpNode.val;
if (tmpNode.left != null) que.offer(tmpNode.left);//例如root结点，其实这里可以看作将下一层的结点提前放入que中 然后继续外层的while循环
if (tmpNode.right != null) que.offer(tmpNode.right);
}
itemList.add(levelSum / len);
}
return itemList;
}
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 {
/**
* 解法1：队列，迭代。
*/
public List<List<Integer>> levelOrder(Node root) {
List<List<Integer>> list = new ArrayList<>();
Deque<Node> que = new LinkedList<>();
if (root == null) {
return list;
}
que.offerLast(root);
while (!que.isEmpty()) {
int levelSize = que.size();//表示每一行的结点总数
List<Integer> levelList = new ArrayList<>();
for(int i = 0; i < levelSize; i++) {
Node poll = que.pollFirst();
levelList.add(poll.val);
List<Node> children = poll.children;
if (children == null || children.size() == 0) {
continue;
}
//如果children不为null，例如1的children为2 3 4 将每个child放入que中 为下一次while循环做准备
//尽管for循环遍历到3位置，poll.children不为null, que中继续可以添加5 6, 这次的5 6不会在本轮for循环中执行，因为levelSize控制了本轮次数
for (Node child : children) {
if (child != null) {//这里的判断 就是剔除了每一行的null
que.offerLast(child);
}
}
}
list.add(levelList);
}
return list;
}
}
class Solution {
public List<Integer> largestValues(TreeNode root) {
List<Integer> retVal = new ArrayList<Integer>();//记录最终要返回的结果
Queue<TreeNode> tmpQueue = new LinkedList<TreeNode>();//用来临时存放每一行的结点
if(root != null) {
tmpQueue.add(root);//临时添加第一行的结点到tmpQueue中，以后的每一行结点的添加都在下面的if判断中
}
while(tmpQueue.size() != 0) {
List<Integer> lvlVals = new ArrayList<Integer>();//用来存放每一行的结点值 从tmpQueue逐个取出结点值
int size = tmpQueue.size();
for(int index = 0; index < size; index++) {
//下面两行将结点值放到lvlVals中
TreeNode node = tmpQueue.poll();
lvlVals.add(node.val);
//下面的判断是将下一行的结点提前添加到tmpQueue中 为下一次的while循环做准备
if(node.left != null) {
tmpQueue.add(node.left);
}
if(node.right != null) {
tmpQueue.add(node.right);
}
}
//for循环过后计算最大值
retVal.add(Collections.max(lvlVals));
}
return retVal;
}
}
package com.tree.java;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class seven {
}
/**
* 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 Node connect(Node root) {
Queue<Node> tmpQueue = new LinkedList<Node>();//用于保存当前行的所有结点
if(root != null) {//首先将第一行的root结点添加到tmpQueue中 进行while循环 之后从下面的if语句来更新添加下一行的结点
tmpQueue.add(root);
}
while(tmpQueue.size() != 0) {
int size = tmpQueue.size();
//以题目中的第二行数据为例：第一次cur指向2 下面for循环中的next指向了3
Node cur = tmpQueue.poll();
if(cur.left != null) {//这里的if语句和下面的if语句都是为了将 子结点提前添加到tmpQueue中 为下一伦次while循环做准备
tmpQueue.add(cur.left);
}
if(cur.right != null) {
tmpQueue.add(cur.right);
}
for(int index = 1; index < size; index++) {
Node next = tmpQueue.poll();//其实这里的next就是相对于index的next结点
if(next.left != null) {
tmpQueue.add(next.left);
}
if(next.right != null) {
tmpQueue.add(next.right);
}
//下面两行操作就是添加上了每个向右的指针 并且使cur每次都向右移动一个结点
cur.next = next;
cur = next;
}
}
return root;
}
}
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;
}
}
package com.tree.java;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class seven {
}
/**
* 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 Node connect(Node root) {
Queue<Node> queue = new LinkedList<Node>();//用于保存当前行的所有结点
if(root != null) {//首先将第一行的root结点添加到tmpQueue中 进行while循环 之后从下面的if语句来更新添加下一行的结点
queue.add(root);
}
while(!queue.isEmpty()) {
int size = queue.size();
Node node = null;
Node nodePre = null;
for(int i = 0;i < size; i++) {
if(i == 0) {
nodePre = queue.poll();//取出本层头一个结点，for循环只能遍历到nodePre指向最后一个结点位置处结束
node = nodePre;
}else {
node = queue.poll();//如果i!=0 node指向下一个结点
nodePre.next = node;//本层前一个结点 next 指向当前结点 即添加指向
nodePre = nodePre.next;//nodePre向前移动
}
//判断node结点的左右结点来更新queue的下一行结点 继续while循环
if(node.left != null) {
queue.add(node.left);
}
if(node.right != null) {
queue.add(node.right);
}
}
nodePre.next = null;//本层最后一个结点next指向null
}
return root;
}
}
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;
}
}
public int maxDepth(TreeNode root) {
if(root == null) {
return 0;
}
Queue<TreeNode> que = new LinkedList<>();//用来记录每一层的结点
que.offer(root);//初始化 添加第一层的root结点数据 进入while循环
int depth = 0;
while(!que.isEmpty()) {
int len = que.size();
while(len > 0) {
TreeNode node = que.poll();//弹出结点
//if语句为下一轮的while循环做准备，提前加入一下行的所有结点到que中
if(node.left != null) {
que.offer(node.left);
}
if(node.right != null) {
que.offer(node.right);
}
len--;
}
//退出内层while循环后，说明遍历完毕一行 depth++
depth++;
}
return depth;
}
3374
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
