Tree_Graph BST每层节点构成链表 (BFS新模板) @CareerCup

原文：

Given a binary search tree, design an algorithm which creates a linked list of all the nodes at each depth (i.e., if you have a tree with depth D, you’ll have D linked lists).

译文：

给定一棵二叉查找树，设计算法，将每一层的所有结点构建为一个链表(也就是说， 如果树有D层，那么你将构建出D个链表)

思路：

好题！可以用DFS和BFS两种方法做。

DFS：先处理root节点，把root节点插入到相应的level链表中（如果链表还没建立就建立以下），再处理左右子树，相当于前序遍历

BFS：还是用一个队列形式。不过是用了一个while+for的方式。非常方便的解决了问题！

Both Time Complexity: O(n), space complexity: O(n)

把模板列在这里：

while( cur.size() > 0 ) {
			result.add(cur);
			LinkedList<TreeNode> oldCur = cur;		// 保存原链表
			cur = new LinkedList<TreeNode>();		// 新建链表为保存下一层的节点
			for(TreeNode node : oldCur) {
				if(node.left != null) {
					cur.add(node.left);
				}
				if(node.right != null) {
					cur.add(node.right);
				}
			}
		}

package Tree_Graph;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;

import CtCILibrary.AssortedMethods;
import CtCILibrary.TreeNode;

public class S4_4 {

	// ================================= DFS递归，先序遍历
	public static ArrayList<LinkedList<TreeNode>> createLevelLinkedListDFS(TreeNode root) {
		ArrayList<LinkedList<TreeNode>> lists = new ArrayList<LinkedList<TreeNode>>();
		createLevelLinkedListRec(root, lists, 0);
		return lists;
	}
	
	public static void createLevelLinkedListRec(TreeNode root, ArrayList<LinkedList<TreeNode>> lists, int level) {
		if(root == null) {
			return;
		}
		
		LinkedList<TreeNode> list = null;
		if(level < lists.size()) {		// 已经存在于lists中，直接取出
			list = lists.get(level);
		} else {			// 否则新建
			list = new LinkedList<TreeNode>();
			lists.add(list);
		}
		
		list.add(root);
		
		// 递归处理左右子树
		createLevelLinkedListRec(root.left, lists, level+1);
		createLevelLinkedListRec(root.right, lists, level+1);
	}
	
	
	// ================================= BFS
	public static ArrayList<LinkedList<TreeNode>> createLevelLinkedListBFS(TreeNode root) {
		ArrayList<LinkedList<TreeNode>> result = new ArrayList<LinkedList<TreeNode>>();
		
		LinkedList<TreeNode> cur = new LinkedList<TreeNode>();
		if(root != null) {
			cur.add(root);
		}
		
		while( cur.size() > 0 ) {
			result.add(cur);
			LinkedList<TreeNode> oldCur = cur;		// 保存原链表
			cur = new LinkedList<TreeNode>();		// 新建链表为保存下一层的节点
			for(TreeNode node : oldCur) {
				if(node.left != null) {
					cur.add(node.left);
				}
				if(node.right != null) {
					cur.add(node.right);
				}
			}
		}
		
		return result;
	}
	
	
	public static void printResult(ArrayList<LinkedList<TreeNode>> result) {
		int depth = 0;
		for(LinkedList<TreeNode> list : result) {
			Iterator<TreeNode> itr = list.iterator();
			System.out.print("Link List at depth " + depth + ":");
			while(itr.hasNext()) {
				System.out.print(" " + itr.next().data);
			}
			System.out.println();
			depth++;
		}
	}
	
	public static void main(String[] args) {
		int[] nodes_flattened = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
		TreeNode root = AssortedMethods.createTreeFromArray(nodes_flattened);
		
//		TreeNode root = new TreeNode(1);
//		root.left = new TreeNode(2);
//		root.left.left = new TreeNode(3);
		
//		ArrayList<LinkedList<TreeNode>> list = createLevelLinkedListDFS(root);
		ArrayList<LinkedList<TreeNode>> list = createLevelLinkedListBFS(root);
		printResult(list);
	}
	
}