程序员面试经典--创建二叉树层结点链表

4.4问题：

给定一棵二叉树，设计一个算法，创建含有某一深度上所有节点的链表（比如，若一棵树的深度为D，则会创建出D个链表）。

思考：

1、我们可以将前序遍历稍加修改，将leve+1传入下一个递归调用。下面是使用深度优先搜索的实现代码。

	public void createLevelLinkedList(Node root,ArrayList<LinkedList<Node>> lists,int level){//先序遍历--深度优先搜索法
		if(root == null) return;
		LinkedList<Node> list = null;
		if(lists.size() == level){
			list = new LinkedList<Node>();
			lists.add(list);
		}else{
			list = lists.get(level);
		}
		list.add(root);
		createLevelLinkedList(root.leftChild,lists,level + 1);
		createLevelLinkedList(root.rightChild,lists,level + 1);
	}
	public ArrayList<LinkedList<Node>> createLevelLinkedList(Node root){
		ArrayList<LinkedList<Node>> lists = new ArrayList<LinkedList<Node>>();
		createLevelLinkedList(root,lists,0);
		return lists;
	}

2、另一种做法是对广度有限算法稍加修改，即从根节点开始迭代，然后第2层，第3层，等等。处于第i层的时候，则表明我们已经访问过第i-1层的所有结点。也就是说，要得到i层的结点，只需直接查看i-1层结点的所有子结点即可。

	public ArrayList<LinkedList<Node>> createLevelLinkedList2(Node root){//广度优先搜索法
		ArrayList<LinkedList<Node>> result = new ArrayList<LinkedList<Node>>();
		LinkedList<Node> current = new LinkedList<Node>();
		if(root!=null){
			current.add(root);
		}
		while(current.size()>0){
			result.add(current);//加入上一层
			LinkedList<Node> parents = current;//转到下一层
			current = new LinkedList<Node>();
			for(Node parent : parents){
				if(parent.leftChild!=null){
					current.add(parent.leftChild);
				}
				if(parent.rightChild!=null){
					current.add(parent.rightChild);
				}
			}
		}
		return result;
	}

完整测试程序：

import java.util.*;
 
class Node {
	Node leftChild;
	Node rightChild;
	int data;
	
	Node(int newData) {//构造方法
		leftChild = null;
		rightChild = null;
		data = newData;
	}
}

class BinTreeTraverse{//创建的为完全二叉树。
	public static Node createMinimalBST(int arr[],int start,int end){
		if(end<start){
			return null;
		}
		int mid = (start+end)/2;
		Node n = new Node(arr[mid]);
		n.leftChild = createMinimalBST(arr,start,mid - 1);
		n.rightChild = createMinimalBST(arr,mid + 1,end);
		return n;
	}
	public static Node createMinimalBST(int array[]){//方法重载
		return createMinimalBST(array,0,array.length - 1);
	}
	
	public void createLevelLinkedList(Node root,ArrayList<LinkedList<Node>> lists,int level){//先序遍历--深度优先搜索法
		if(root == null) return;
		LinkedList<Node> list = null;
		if(lists.size() == level){
			list = new LinkedList<Node>();
			lists.add(list);
		}else{
			list = lists.get(level);
		}
		list.add(root);
		createLevelLinkedList(root.leftChild,lists,level + 1);
		createLevelLinkedList(root.rightChild,lists,level + 1);
	}
	public ArrayList<LinkedList<Node>> createLevelLinkedList(Node root){
		ArrayList<LinkedList<Node>> lists = new ArrayList<LinkedList<Node>>();
		createLevelLinkedList(root,lists,0);
		return lists;
	}
	
	public ArrayList<LinkedList<Node>> createLevelLinkedList2(Node root){//广度优先搜索法
		ArrayList<LinkedList<Node>> result = new ArrayList<LinkedList<Node>>();
		LinkedList<Node> current = new LinkedList<Node>();
		if(root!=null){
			current.add(root);
		}
		while(current.size()>0){
			result.add(current);//加入上一层
			LinkedList<Node> parents = current;//转到下一层
			current = new LinkedList<Node>();
			for(Node parent : parents){
				if(parent.leftChild!=null){
					current.add(parent.leftChild);
				}
				if(parent.rightChild!=null){
					current.add(parent.rightChild);
				}
			}
		}
		return result;
	}
	
	/**
	 * 先序遍历
	 */
	public static void preOrderTraverse(Node node){
		if (node == null)
			return;
		System.out.print(node.data + " ");
		preOrderTraverse(node.leftChild);
		preOrderTraverse(node.rightChild);
	}

	/**
	 * 中序遍历
	 */
	public static void inOrderTraverse(Node node) {
		if (node == null)
			return;
		inOrderTraverse(node.leftChild);
		System.out.print(node.data + " ");
		inOrderTraverse(node.rightChild);
	}

	/**
	 * 后序遍历
	 */
	public static void postOrderTraverse(Node node) {
		if (node == null)
			return;
		postOrderTraverse(node.leftChild);
		postOrderTraverse(node.rightChild);
		System.out.print(node.data + " ");
	}
}

class LevellinkedList{
	public static void main(String[] args){
		int array[]=new int[9];
		for(int i=0;i<array.length;){
			array[i]=++i;
		}
		
		//建立二叉树以及遍历
		System.out.println("二叉树建立以及遍历：");
		BinTreeTraverse binTree = new BinTreeTraverse();
		Node root = binTree.createMinimalBST(array);
		
		System.out.println("先序遍历：");
		binTree.preOrderTraverse(root);
		System.out.println();
		
		System.out.println("中序遍历：");
		binTree.inOrderTraverse(root);
		System.out.println();
		
		System.out.println("后序遍历：");
		binTree.postOrderTraverse(root);
		
		ArrayList<LinkedList<Node>> lists = new ArrayList<LinkedList<Node>>();
		lists = binTree.createLevelLinkedList2(root);
 		for(LinkedList<Node> list:lists){//增强型for循环遍历
			System.out.println();
			for(Node n: list){//增强型for循环遍历
				System.out.print(n.data+"->");
			}
		}
		
		System.exit(0);
	}
}