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);
}
}