【Leetcode】102. Binary Tree Level Order Traversal

287 阅读1分钟

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:

tree1.jpg
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; 
};