Given the root of a binary tree, return the level order traversal of its nodes' values. (i.e., from left to right, level by level). Example1:
Input: root = [3,9,20,null,null,15,7]
Output: [[3],[9,20],[15,7]]
Example 2:
Input: root = [1]
Output: [[1]]
Example 3:
Input: root = []
Output: []
Constraints:
- The number of nodes in the tree is in the range [0, 2000].
- -1000 <= Node.val <= 1000
Breadth First Search
Java version
下面这个版本的代码比较简单直观
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> list = new ArrayList<List<Integer>>();
if(root == null) return list;
// 用一个arraylist来装每一个level的nodes
ArrayList<TreeNode> nodeList = new ArrayList<TreeNode>();
nodeList.add(root);
int level = 0;
while(!nodeList.isEmpty()) {
// 获取每一个level的nodes的values
list.add(new ArrayList<Integer>());
int size = nodeList.size();
for(int i = 0; i < size; i++) {
list.get(level).add(nodeList.get(i).val);
}
level++;
ArrayList<TreeNode> temp = new ArrayList<TreeNode>();
for(int i = 0; i < size; i++) {
TreeNode left = nodeList.get(i).left;
TreeNode right = nodeList.get(i).right;
if(left != null) temp.add(left);
if(right != null) temp.add(right);
}
nodeList = temp;
}
return list;
}
}
Depth First Search
用Depth First Search来解题的时候,会用到Recursion,代码会比较简洁。同时,DFS有preorder, inorder和postorder,这几种方式应该都能解题。
针对我个人来讲,recursion会比上面的BFS更抽象一点,可以通过实例画图来帮助写代码。
Java版
/**
* 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 {
private static int level = 0;
private static List<List<Integer>> list = new ArrayList<List<Integer>>();
public void preorder(TreeNode node) {
// base condition of recursion
if(node == null) return;
if(list.size() == level) {
list.add(new ArrayList<Integer>());
}
list.get(level).add(node.val);
level++;
preorder(node.left);
preorder(node.right);
level--;
}
public List<List<Integer>> levelOrder(TreeNode root) {
if(root == null) return list;
list.add(new ArrayList<Integer>());
preorder(root);
// reset the value of list
List<List<Integer>> result = list;
list = new ArrayList<List<Integer>>();
return result;
}
}
JavaScript版
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {number[][]}
*/
var level = 0;
var array = [];
function preorder(node) {
if(node === null) return;
if(array.length === level)
array[level] = [];
array[level].push(node.val);
level++;
preorder(node.left);
preorder(node.right);
level--;
}
var levelOrder = function(root) {
// check if the root is empty
if(root === null) {
return array;
}
// 初始化
array[level] = [];
preorder(root);
// reset
let result = array;
array = [];
return result;
};