这题用递归做
class Solution {
List<List<Integer>> res = new ArrayList<>();
public List<List<Integer>> levelOrderBottom(TreeNode root) {
checkfun(root,0);
int left = 0;
int right = res.size() - 1;
while(left < right){
List<Integer> tmp = res.get(left);
res.set(left,res.get(right));
res.set(right,tmp);
left++;
right--;
}
return res;
}
public void checkfun(TreeNode node, int deep){
if(node == null) return;
deep++;
while(res.size() < deep){
List<Integer> temp = new ArrayList<>();
res.add(temp);
}
res.get(deep - 1).add(node.val);
checkfun(node.left,deep);
checkfun(node.right,deep);
}
}
这题用迭代法做
class Solution {
public List<Integer> rightSideView(TreeNode root) {
List<Integer> res = new ArrayList<>();
Queue<TreeNode> queue = new LinkedList<>();
Integer tmp;
if(root == null) return res;
queue.offer(root);
while(!queue.isEmpty()){
int len = queue.size();
while(len > 0){
TreeNode node = queue.poll();
if(len == 1)res.add(node.val);
if(node.left != null) queue.offer(node.left);
if(node.right != null) queue.offer(node.right);
len--;
}
}
return res;
}
}
class Solution {
public List<Double> averageOfLevels(TreeNode root) {
if(root == null) return null;
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
List<Double> ans = new ArrayList<>();
while(!queue.isEmpty()){
double sum = 0;
int len = queue.size();
int num = len;
while(len > 0){
TreeNode node = queue.poll();
sum += node.val;
if(node.left != null) queue.offer(node.left);
if(node.right != null) queue.offer(node.right);
len--;
}
ans.add(sum/num);
}
return ans;
}
}
这里用自己的代码和官方答案,官方答案永远是2ms我的永远是3ms,就算改到一模一样都是我多1ms,后来发现我的sum声明是Double,用double就可以了。
这题用递归法
/*
// 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<>();
public List<List<Integer>> levelOrder(Node root) {
checkfun(root,0);
return res;
}
public void checkfun(Node node, int deep){
if(node == null) return;
deep++;
while(res.size() < deep){
List<Integer> arr = new ArrayList<>();
res.add(arr);
}
res.get(deep - 1).add(node.val);
for(Node i:node.children){
checkfun(i,deep);
}
}
}
使用迭代法
class Solution {
public List<Integer> largestValues(TreeNode root) {
List<Integer> res = new ArrayList<>();
if(root == null) return res;
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
while(!queue.isEmpty()) {
int size = queue.size();
int max = queue.peek().val;
while(size > 0) {
TreeNode node = queue.poll();
max = Math.max(max,node.val);
if(node.left != null) queue.add(node.left);
if(node.right != null) queue.add(node.right);
size--;
}
res.add(max);
}
return res;
}
}
BFS的空间复杂度O(1)版本,我是秀儿
class Solution {
public Node connect(Node root) {
if(root == null || root.left == null) return root;
Node tmp = root;
//处理树的h-1层
while(tmp.left != null){
//先把树的最左边的节点的left.next指向right
tmp.left.next = tmp.right;
//为了while函数中对节点的改动不影响tmp
Node pre = tmp;
while(pre.next != null){
//把这个节点的下一层的节点处理了(官方题解,方法二中的第二种情况)
pre.right.next = pre.next.left;
//节点右移
pre = pre.next;
//把这个节点自己的左右孩子连起来
pre.left.next = pre.right;
}
//移向下一层的最左节点
tmp = tmp.left;
}
return root;
}
}
class Solution {
public Node connect(Node root) {
//每一层的头结点
Node dummy = new Node();
dummy.next = root;
while(dummy.next != null) {
Node pre = dummy;
Node cur = dummy.next;
//最后一层的话,while循环内的if条件不触发,dummy.next == null,外层while循环停止
dummy.next = null;
while(cur != null) {
if(cur.left != null){
pre.next = cur.left;
pre = cur.left;
}
if(cur.right != null){
pre.next = cur.right;
pre = cur.right;
}
cur = cur.next;
}
}
return root;
}
}
太强了这个代码,搞了半天才弄懂,用链表对每一层进行串联,用哑结点连通第一个存在的点,然后向这一层的后续节点进行遍历。因为哑结点连的是下一层的起点,所以可以利用哑结点继续下一层遍历