递归方式层序遍历
class Solution {
List<List<Integer>> levels = new ArrayList<>();
public void helper(TreeNode node, int level){
if(levels.size() == level){
levels.add(new ArrayList<Integer>());
}
levels.get(level).add(node.val);
if(node.left != null)
helper(node.left,level+1);
if(node.right != null)
helper(node.right,level+1);
}
public List<List<Integer>> levelOrder(TreeNode root) {
if(root == null) return levels;
helper(root,0);
return levels;
}
}
本种解法,利用到了ArrayList存储了一些List<Integer>,每个list就是每一层,其中有一层的所有元素,精髓的就是,levels.get(level).add(node.val)
迭代方式层序遍历
class Solution {
List<List<Integer>> resList = new ArrayList<List<Integer>>();
public void helper(TreeNode node){
Deque<TreeNode> dq = new LinkedList<TreeNode>();
if(node == null) return;
dq.offer(node);
while(!dq.isEmpty()){
int len = dq.size();
List<Integer> list = new ArrayList<>();
while(len!= 0){
TreeNode tempNode = dq.poll();
list.add(tempNode.val);
if(tempNode.left != null) dq.offer(tempNode.left);
if(tempNode.right != null) dq.offer(tempNode.right);
len--;
}
resList.add(list);
}
}
public List<List<Integer>> levelOrder(TreeNode root) {
helper(root);
return resList;
}
}
重点是要想清楚,队列中每次弹出以后都要加入子节点的话,怎么才算遍历完一层,那么解决办法就是每次遍历完一层 先进行队列的size取值 知道size有多少后赋值给一个控制循环的变量,这样在poll对应的元素之后就返回一个List<Integer> 这个就要加入到大的List<List<Integer>>中去, 这样就是一层了
107 层序遍历II
重点是知道add(int index, element) 这个方法,就是在指定位置插入元素,题目要求是从下往上遍历,那么就在resList中一直在0这个位置插入元素,遍历顺序还是从上往下遍历,但是插入结果列表中时 是一直在0的位置插入就成从下往上遍历列表了
class Solution {
List<List<Integer>> resList = new ArrayList<>();
Deque<TreeNode> dq = new LinkedList<>();
public void helper(TreeNode node){
if(node == null)return;
dq.offer(node);
while(!dq.isEmpty()){
int len = dq.size();
List<Integer> list = new ArrayList<>();
while(len > 0){
TreeNode tempNode = dq.poll();
list.add(tempNode.val);
if(tempNode.left != null)
dq.offer(tempNode.left);
if(tempNode.right != null)
dq.offer(tempNode.right);
len--;
}
resList.add(0,list);
}
}
public List<List<Integer>> levelOrderBottom(TreeNode root) {
helper(root);
return resList;
}
}
199二叉树右视图
class Solution {
Deque<TreeNode> curLevel = new ArrayDeque<>();
Deque<TreeNode> nextLevel = new ArrayDeque<>();
List<Integer> res = new ArrayList<>();
public List<Integer> rightSideView(TreeNode root) {
TreeNode tempNode = null;
if(root == null)return res;
nextLevel.offer(root);
while(!nextLevel.isEmpty()){
curLevel = nextLevel;
nextLevel = new ArrayDeque<>();
while(!curLevel.isEmpty()){
tempNode = curLevel.poll();
if(tempNode.left!=null)
nextLevel.offer(tempNode.left);
if(tempNode.right!=null)
nextLevel.offer(tempNode.right);
}
res.add(tempNode.val);
}
return res;
}
}
637二叉树层平均值
class Solution {
Deque<TreeNode> dq = new ArrayDeque<>();
List<Double> res = new ArrayList<>();
TreeNode tempNode = null;
public List<Double> averageOfLevels(TreeNode root) {
if(root == null)return res;
dq.offer(root);
double len = 0;
double sum = 0;
while(!dq.isEmpty()){
len = dq.size(); //重置该层size
double devise = len;
sum = 0; //重置sum
while(len > 0){
tempNode = dq.poll();
if(tempNode.left != null)
dq.offer(tempNode.left);
if(tempNode.right != null)
dq.offer(tempNode.right);
sum += tempNode.val;
len--;
}
res.add(sum/devise);
}
return res;
}
}
429 N叉树的层序遍历
/*
// 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 {
List<List<Integer>> res = new ArrayList<>();
Deque<Node> dq = new ArrayDeque<>();
int levelsize = 0;
public List<List<Integer>> levelOrder(Node root) {
if(root == null)return res;
dq.offerLast(root);
while(!dq.isEmpty()){
List<Integer> levelList = new ArrayList<>();
levelsize = dq.size();
for(int i = 0; i < levelsize; i++){
Node tempNode = dq.pollFirst();
levelList.add(tempNode.val);
if(tempNode.children == null || tempNode.children.size() == 0){
continue;
}
List<Node> childrenList = new ArrayList<>();
childrenList = tempNode.children;
for(Node node : childrenList){
if(node != null){
dq.offerLast(node);
}
}
}
res.add(levelList);
}
return res;
}
}
核心是新建一个list<Node>存储 tempNode的children列表,然后用迭代器for(Node child : childrenList)来遍历每一个子节点。
116填充每个节点的下一个右侧节点指针
class Solution {
Deque<Node> dq = new ArrayDeque<>();
public Node connect(Node root) {
if(root == null)return root;
dq.offer(root);
int levelSize = 0;
while(!dq.isEmpty()){
levelSize = dq.size();
Node cur = dq.poll();
if(cur.left != null)
dq.offer(cur.left);
if(cur.right != null)
dq.offer(cur.right);
for(int index = 1; index < levelSize; index++){
Node next = dq.poll();
if(next.left != null)
dq.offer(next.left);
if(next.right != null)
dq.offer(next.right);
cur.next = next;
cur = next;
}
}
return root;
}
}
117填充每个节点的下一个右侧节点指针
同上
104 二叉树的最大深度
class Solution {
Deque<TreeNode> dq = new ArrayDeque<>();
int depth = 0;
int levelSize = 0;
public int maxDepth(TreeNode root) {
if(root == null) return 0;
dq.offer(root);
while(!dq.isEmpty()){
levelSize = dq.size();
for(int i = 0; i < levelSize ; i++){
TreeNode tempNode = dq.poll();
if(tempNode.left != null)
dq.offer(tempNode.left);
if(tempNode.right != null)
dq.offer(tempNode.right);
}
depth++;
}
return depth;
}
}
111 二叉树最小深度
class Solution {
Deque<TreeNode> dq = new ArrayDeque<>();
int depth = 0;
public int minDepth(TreeNode root) {
if(root == null)return 0;
dq.offer(root);
int levelSize = 0;
while(!dq.isEmpty()){
levelSize = dq.size();
depth++;
for(int i = 0; i < levelSize ; i++){
TreeNode tempNode = dq.poll();
if(tempNode.left == null && tempNode.right == null){
return depth;
}
if(tempNode.left!=null)
dq.offer(tempNode.left);
if(tempNode.right!=null)
dq.offer(tempNode.right);
}
}
return depth;
}
}