LeetCode - Medium - 102. Binary Tree Level Order Traversal

Topic

• Tree
• Breadth-first Search

Description

https://leetcode.com/problems/binary-tree-level-order-traversal/

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).

Example 1:

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

Analysis

方法一：DFS

方法二：BFS

Submission

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

import com.lun.util.BinaryTree.TreeNode;

public class BinaryTreeLevelOrderTraversal {
	
	//方法一：DFS
    public List<List<Integer>> levelOrder(TreeNode root) {
    	List<List<Integer>> result = new ArrayList<>();
    	levelOrder(root, 0, result);
        return result;
    }
    
    private void levelOrder(TreeNode node, int level, List<List<Integer>> result) {
    	if(node == null) return;
    	
    	if(level == result.size()) {
    		List<Integer> temp = new ArrayList<>();
    		temp.add(node.val);
    		result.add(temp);
    	}else {
    		result.get(level).add(node.val);
    	}
    	
    	levelOrder(node.left, level + 1, result);
    	levelOrder(node.right, level + 1, result);
    	
    }

    //方法二：BFS
	public List<List<Integer>> levelOrder2(TreeNode root) {
		List<List<Integer>> result = new ArrayList<>();
		if(root == null) return result;
		
		LinkedList<TreeNode> queue = new LinkedList<>();
		queue.offer(root);
		
		while(!queue.isEmpty()) {
			List<Integer> temp = new ArrayList<>();
			
			for(int size = queue.size(); size > 0; size--) {
				TreeNode node = queue.poll();
				temp.add(node.val);
				
				if(node.left != null)
					queue.offer(node.left);
				
				if(node.right != null)
					queue.offer(node.right);
			}
			
			result.add(temp);
		}
		
		return result;
	}
    
}

Test

import static org.junit.Assert.*;

import java.util.Arrays;

import org.hamcrest.collection.IsEmptyCollection;
import org.hamcrest.collection.IsIterableContainingInOrder;
import org.junit.Test;

import com.lun.util.BinaryTree;

public class BinaryTreeLevelOrderTraversalTest {

	@SuppressWarnings("unchecked")
	@Test
	public void test() {
		BinaryTreeLevelOrderTraversal obj = new BinaryTreeLevelOrderTraversal();

		assertThat(obj.levelOrder(BinaryTree.integers2BinaryTree(3,9,20,null,null,15,7)), //
				IsIterableContainingInOrder.contains(Arrays.asList(3), Arrays.asList(9,20), Arrays.asList(15,7)));
		assertThat(obj.levelOrder(BinaryTree.integers2BinaryTree(1)), //
				IsIterableContainingInOrder.contains(Arrays.asList(1)));
		assertThat(obj.levelOrder(null), IsEmptyCollection.empty());
	}
	
	@SuppressWarnings("unchecked")
	@Test
	public void test2() {
		BinaryTreeLevelOrderTraversal obj = new BinaryTreeLevelOrderTraversal();
		
		assertThat(obj.levelOrder2(BinaryTree.integers2BinaryTree(3,9,20,null,null,15,7)), //
				IsIterableContainingInOrder.contains(Arrays.asList(3), Arrays.asList(9,20), Arrays.asList(15,7)));
		assertThat(obj.levelOrder2(BinaryTree.integers2BinaryTree(1)), //
				IsIterableContainingInOrder.contains(Arrays.asList(1)));
		assertThat(obj.levelOrder2(null), IsEmptyCollection.empty());
	}
}