algorithm/leetcode-master
1
0
Fork 0
mirror of https://github.com/youngyangyang04/leetcode-master.git synced 2025-07-09 19:44:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

添加 0102.二叉树的层序遍历.md Java版本

Browse Source
This commit is contained in:
h2linlin
2021-05-13 21:25:03 +08:00
parent 11cfcdf1b9
commit 0eba147159
1 changed files with 205 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

228
problems/0102.二叉树的层序遍历.md
View File

@ -420,54 +420,236 @@ public:
Java： Java：
```Java ```Java
// 102.二叉树的层序遍历
class Solution { class Solution {
public List<List<Integer>> resList=new ArrayList<List<Integer>>(); public List<List<Integer>> resList = new ArrayList<List<Integer>>();
public List<List<Integer>> levelOrder(TreeNode root) { public List<List<Integer>> levelOrder(TreeNode root) {
//checkFun01(root,0); //checkFun01(root,0);
checkFun02(root); checkFun02(root);
return resList; return resList;
} }
//DFS--递归方式 //DFS--递归方式
public void checkFun01(TreeNode node,Integer deep){ public void checkFun01(TreeNode node, Integer deep) {
if(node==null) return; if (node == null) return;
deep++; deep++;
if(resList.size()<deep){ if (resList.size() < deep) {
//当层级增加时，list的Item也增加，利用list的索引值进行层级界定 //当层级增加时，list的Item也增加，利用list的索引值进行层级界定
List<Integer> item=new ArrayList<Integer>(); List<Integer> item = new ArrayList<Integer>();
resList.add(item); resList.add(item);
} }
resList.get(deep-1).add(node.val); resList.get(deep - 1).add(node.val);
checkFun01(node.left,deep); checkFun01(node.left, deep);
checkFun01(node.right,deep); checkFun01(node.right, deep);
} }
//BFS--迭代方式--借助队列 //BFS--迭代方式--借助队列
public void checkFun02(TreeNode node){ public void checkFun02(TreeNode node) {
if(node==null) return; if (node == null) return;
Queue<TreeNode> que=new LinkedList<TreeNode>(); Queue<TreeNode> que = new LinkedList<TreeNode>();
que.offer(node); que.offer(node);
while(!que.isEmpty()){ while (!que.isEmpty()) {
List<Integer> itemList=new ArrayList<Integer>(); List<Integer> itemList = new ArrayList<Integer>();
int len=que.size(); int len = que.size();
while(len>0){ while (len > 0) {
TreeNode tmpNode=que.poll(); TreeNode tmpNode = que.poll();
itemList.add(tmpNode.val); itemList.add(tmpNode.val);
if(tmpNode.left!=null) que.offer(tmpNode.left); if (tmpNode.left != null) que.offer(tmpNode.left);
if(tmpNode.right!=null) que.offer(tmpNode.right); if (tmpNode.right != null) que.offer(tmpNode.right);
len--; len--;
} }
resList.add(itemList); resList.add(itemList);
} }
} }
}
// 107. 二叉树的层序遍历 II
public class N0107 {
/**
* 解法：队列，迭代。
* 层序遍历，再翻转数组即可。
*/
public List<List<Integer>> solution1(TreeNode root) {
List<List<Integer>> list = new ArrayList<>();
Deque<TreeNode> que = new LinkedList<>();
if (root == null) {
return list;
}
que.offerLast(root);
while (!que.isEmpty()) {
List<Integer> levelList = new ArrayList<>();
int levelSize = que.size();
for (int i = 0; i < levelSize; i++) {
TreeNode peek = que.peekFirst();
levelList.add(que.pollFirst().val);
if (peek.left != null) {
que.offerLast(peek.left);
}
if (peek.right != null) {
que.offerLast(peek.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;
}
}
// 199.二叉树的右视图
public class N0199 {
/**
* 解法：队列，迭代。
* 每次返回每层的最后一个字段即可。
*
* 小优化：每层右孩子先入队。代码略。
*/
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 levelSize = que.size();
for (int i = 0; i < levelSize; i++) {
TreeNode poll = que.pollFirst();
if (poll.left != null) {
que.addLast(poll.left);
}
if (poll.right != null) {
que.addLast(poll.right);
}
if (i == levelSize - 1) {
list.add(poll.val);
}
}
}
return list;
}
}
// 637. 二叉树的层平均值
public class N0637 {
/**
* 解法：队列，迭代。
* 每次返回每层的最后一个字段即可。
*/
public List<Double> averageOfLevels(TreeNode root) {
List<Double> list = new ArrayList<>();
Deque<TreeNode> que = new LinkedList<>();
if (root == null) {
return list;
}
que.offerLast(root);
while (!que.isEmpty()) {
TreeNode peek = que.peekFirst();
int levelSize = que.size();
double levelSum = 0.0;
for (int i = 0; i < levelSize; i++) {
TreeNode poll = que.pollFirst();
levelSum += poll.val;
if (poll.left != null) {
que.addLast(poll.left);
}
if (poll.right != null) {
que.addLast(poll.right);
}
}
list.add(levelSum / levelSize);
}
return list;
}
}
// 429. N 叉树的层序遍历
public class N0429 {
/**
* 解法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;
}
for (Node child : children) {
if (child != null) {
que.offerLast(child);
}
}
}
list.add(levelList);
}
return list;
}
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;
}
}
}
``` ```