LeetCode Top 100 Liked Questions 102. Binary Tree Level Order Traversal (Java版； Medium)

welcome to my blog

LeetCode Top 100 Liked Questions 102. Binary Tree Level Order Traversal (Java版; Medium)

题目描述

Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).

For example:
Given binary tree [3,9,20,null,null,15,7],
    3
   / \
  9  20
    /  \
   15   7
return its level order traversal as:
[
  [3],
  [9,20],
  [15,7]
]

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> list = new ArrayList<>();
        if(root==null){
            return list;
        }
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            int n = queue.size();
            List<Integer> al = new ArrayList<>();
            for(int i=0; i<n; i++){
                TreeNode cur = queue.poll();
                al.add(cur.val);
                if(cur.left!=null){
                    queue.add(cur.left);
                }
                if(cur.right!=null){
                    queue.add(cur.right);
                }
            }
            list.add(al);
        }
        return list;
    }
}

第一次做; 二叉树的层次遍历, 递归版; 递归函数逻辑: 将当前层(当前条件)的节点(当前条件)加入到res中, 递归处理下一层(新条件)的节点(新条件); 采用前序遍历的方式遍历二叉树, 虽然第一个递归函数会一直处理左孩子, 但是左孩子和其所在的层数对应, 所以最终结果并不会出错

import java.util.List;
import java.util.ArrayList;

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root==null)
            return res;
        //
        Core(res, root, 1);
        return res;
    }
    //递归函数逻辑: 将level层(当前条件)的节点(当前条件)加入到res中, 递归处理在level+1层(新条件)的节点(新条件)
    public static void Core(List<List<Integer>> res, TreeNode root, int level){
        if(root==null)
            return;
        if(res.size()<level)
            res.add(new ArrayList<Integer>());
        res.get(level-1).add(root.val);
        
        //虽然第一个递归, 会一直处理左孩子, 但是并不影响最终的结果, 因为每个左孩子都与自己的层数对应
        Core(res, root.left, level+1);
        Core(res, root.right, level+1);
    }
}

第一次做; 二叉树的层次遍历, 循环版, 借助队列, 需要按层保存结果, 用变量count记录当前层有几个节点要处理, 用变量total记录下一层的节点个数; 每个节点处理一次, 所以时间复杂度O(N); res中保存的是N个值, 所以空间复杂度O(N),

/*
层次遍历二叉树, 需要按层区分
*/
import java.util.List;
import java.util.ArrayList;
import java.util.LinkedList;

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root==null)
            return res;
        //
        int count=1, total=0;
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        TreeNode curr;
        while(!queue.isEmpty()){
            res.add(new ArrayList<Integer>());
            while(count!=0){
                curr = queue.poll();
                res.get(res.size()-1).add(curr.val);
                count--;
                if(curr.left!=null){
                    queue.add(curr.left);
                    total++;
                }
                if(curr.right!=null){
                    queue.add(curr.right);
                    total++;
                }
            }
            count = total;
            total = 0;
        }
        return res;
    }
}