java遍歷多叉樹

『壹』 哪位仁兄有java實現的多叉樹源碼

多叉樹到單鏈表結構的轉換源代碼

由於Animation結構體的定義為單鏈表形式，需要把多叉樹骨骼數據轉換為單鏈表中，十分頭疼。

寫之前要把轉換的邏輯順序想清楚，我在這採取深度優先（先深度後寬度）搜索，類似二叉樹的前序遍歷。把相關的幾個函數帖出，區區幾十行，但要把邏輯順序想明白了，或許還有不對的地方。

/********************************************************
函數名稱：FindFirstLeaf
功能描述：尋找本節點的葉子節點
參數說明：無

返 回 值：葉子節點
*********************************************************/
Frame_EX* Frame_EX::FindFirstLeaf()
{
Frame_EX* pFrame = FirstChildHaveSibling();
if(pFrame == this || pFrame->IsLeaf())
return pFrame;
else
return pFrame->m_pFrameSibling->LastLeaf();
}

//寬度搜索本節點的最後一個兄弟節點，如果沒有則返回自身
Frame_EX* Frame_EX::LastSibling()
{
Frame_EX* pFrame = m_pFrameSibling;
if(!pFrame)
return this;

Frame_EX* pFramePrev;
while(pFrame)
{
pFramePrev = pFrame;
pFrame = pFrame->m_pFrameSibling;
}
return pFramePrev;
}

//深度搜索本節點下第一個有兄弟節點的孩子節點
//如果無孩子節點則返回自身，如果所有孩子節點均無兄弟節點則返回最後一個孩子節點
Frame_EX* Frame_EX::FirstChildHaveSibling()
{
Frame_EX* pFrame = m_pFrameFirstChild;
if(!pFrame)
return this;

Frame_EX* pFrameAfter = pFrame->m_pFrameFirstChild;

while(!pFrame->m_pFrameSibling && pFrameAfter)
{
pFrame = pFrameAfter;
pFrameAfter = pFrameAfter->m_pFrameFirstChild;
}
return pFrame;
}

//寬度優先（先寬度後深度）搜索本節點下最後一個葉子節點
Frame_EX* Frame_EX::LastLeaf()
{
if(IsLeaf())
return this;

Frame_EX* pFrame;
pFrame = LastSibling(); //先寬度
pFrame = pFrame->FirstChildHaveSibling(); //後深度

return pFrame->LastLeaf();
}

/********************************************************
函數名稱：AddAnimationRecursive
功能描述：遞歸創建骨骼動畫
參數說明：pFramePrev 動畫鏈表中上一級動畫相關聯的骨骼
pFrame 待加入到鏈表中的骨骼動畫

返 回 值：無
*********************************************************/
void SkeletonAnimation::AddAnimationRecursive(Frame_EX* pFramePrev, Frame_EX* pFrame)
{
if(!pFrame)
return;

LPAnimation pAnimation = new Animation();
pAnimation->pBoneName = pFrame->m_name;
pAnimation->pBone = pFrame;

//加入當前動畫集合，pFramePrev為NULL加入到m_pAnimationSet中
if(!pFramePrev)
{
pAnimation->pNext = m_pAnimationSet->pAnimations;
m_pAnimationSet->pAnimations = pAnimation;
m_pAnimationSet->nAnimation++;
}
else
{
pAnimation->pNext = NULL;
m_pAnimationSet->Find(pFramePrev)->pNext = pAnimation;
m_pAnimationSet->nAnimation++;
}

if(pFrame->m_pFrameFirstChild)
AddAnimationRecursive(pFrame, pFrame->m_pFrameFirstChild);

if(pFrame->m_pFrameSibling)
AddAnimationRecursive(pFrame->FindFirstLeaf(), pFrame->m_pFrameSibling);
}

『貳』 JAVA多叉樹，遞歸輸出為什麼少了兩行

系統被你打亂出故障了

『叄』 怎樣用Java實現一個多叉樹數據結構

這是一個典型的多叉樹問題！ 最早的祖先用根節點表示，以下依次是他的/她的子女。這個就組成一棵樹。 每一棵樹的數據包括了： 名稱、父節點指針、第一個孩子的指針、配偶指針、下一個兄弟姐妹的指針

『肆』 簡單的JAVA多叉樹問題實現

TreeNode.java
/*
*CopyrightWalkerStudio
*AllRightsReserved.
*
*文件名稱：TreeNode.java
*摘要：
*作者：Walker
*創建時間：2013-03-19
*/
packagecom.walker.commons.data.model;

/**
*樹節點
*
*@authorWalker
*@version1.0.0.0
*/
publicclassTreeNode
{
	/**節點Id*/
	privateStringnodeId;
	/**父節點Id*/
	privateStringparentId;
	/**文本內容*/
	privateStringtext;
	
	/**
	*構造函數
	*
	*@paramnodeId節點Id
	*/
	publicTreeNode(StringnodeId)
	{
		this.nodeId=nodeId;
	}
	
	/**
	*構造函數
	*
	*@paramnodeId節點Id
	*@paramparentId父節點Id
	*/
	publicTreeNode(StringnodeId,StringparentId)
	{
		this.nodeId=nodeId;
		this.parentId=parentId;
	}

	publicStringgetNodeId(){
		returnnodeId;
	}

	publicvoidsetNodeId(StringnodeId){
		this.nodeId=nodeId;
	}

	publicStringgetParentId(){
		returnparentId;
	}

	publicvoidsetParentId(StringparentId){
		this.parentId=parentId;
	}

	publicStringgetText(){
		returntext;
	}

	publicvoidsetText(Stringtext){
		this.text=text;
	}
	
}


ManyTreeNode.java

/*
*CopyrightWalkerStudio
*AllRightsReserved.
*
*文件名稱：ManyTreeNode.java
*摘要：
*作者：Walker
*創建時間：2013-03-19
*/
packagecom.walker.commons.data.model;

importjava.util.ArrayList;
importjava.util.List;

/**
*多叉樹節點
*
*@authorWalker
*@verion1.0.0.0
*/
publicclassManyTreeNode
{
	/**樹節點*/
	privateTreeNodedata;
	/**子樹集合*/
	privateList<ManyTreeNode>childList;
	
	/**
	*構造函數
	*
	*@paramdata樹節點
	*/
	publicManyTreeNode(TreeNodedata)
	{
		this.data=data;
		this.childList=newArrayList<ManyTreeNode>();
	}
	
	/**
	*構造函數
	*
	*@paramdata樹節點
	*@paramchildList子樹集合
	*/
	publicManyTreeNode(TreeNodedata,List<ManyTreeNode>childList)
	{
		this.data=data;
		this.childList=childList;
	}

	publicTreeNodegetData(){
		returndata;
	}

	publicvoidsetData(TreeNodedata){
		this.data=data;
	}

	publicList<ManyTreeNode>getChildList(){
		returnchildList;
	}

	publicvoidsetChildList(List<ManyTreeNode>childList){
		this.childList=childList;
	}

}


ManyNodeTree.java

/*
*CopyrightWalkerStudio
*AllRightsReserved.
*
*文件名稱：ManyNodeTree.java
*摘要：
*作者：Walker
*創建時間：2013-03-19
*/
packagecom.walker.commons.data.model;

importjava.util.ArrayList;
importjava.util.List;

/**
*多叉樹生成、遍歷工具
*
*@authorWalker
*@version1.0.0.0
*/
publicclassManyNodeTree
{
	/**樹根*/
	privateManyTreeNoderoot;
	
	/**
	*構造函數
	*/
	publicManyNodeTree()
	{
		root=newManyTreeNode(newTreeNode("root"));
	}
	
	/**
	*生成一顆多叉樹，根節點為root
	*
	*@paramtreeNodes生成多叉樹的節點集合
	*@returnManyNodeTree
	*/
	publicManyNodeTreecreateTree(List<TreeNode>treeNodes)
	{
		if(treeNodes==null||treeNodes.size()<0)
			returnnull;
		
		ManyNodeTreemanyNodeTree=newManyNodeTree();
		
		//將所有節點添加到多叉樹中
		for(TreeNodetreeNode:treeNodes)
		{
			if(treeNode.getParentId().equals("root"))
			{
				//向根添加一個節點
				manyNodeTree.getRoot().getChildList().add(newManyTreeNode(treeNode));
			}
			else
			{
				addChild(manyNodeTree.getRoot(),treeNode);
			}
		}
		
		returnmanyNodeTree;
	}
	
	/**
	*向指定多叉樹節點添加子節點
	*
	*@parammanyTreeNode多叉樹節點
	*@paramchild節點
	*/
	publicvoidaddChild(ManyTreeNodemanyTreeNode,TreeNodechild)
	{
		for(ManyTreeNodeitem:manyTreeNode.getChildList())
		{
			if(item.getData().getNodeId().equals(child.getParentId()))
			{
				//找到對應的父親
				item.getChildList().add(newManyTreeNode(child));
				break;
			}
			else
			{
				if(item.getChildList()!=null&&item.getChildList().size()>0)
				{
					addChild(item,child);
				}				
			}
		}
	}
	
	/**
	*遍歷多叉樹
	*
	*@parammanyTreeNode多叉樹節點
	*@return
	*/
	publicStringiteratorTree(ManyTreeNodemanyTreeNode)
	{
		StringBuilderbuffer=newStringBuilder();
		buffer.append("
");
		
		if(manyTreeNode!=null)
		{	
			for(ManyTreeNodeindex:manyTreeNode.getChildList())
			{
				buffer.append(index.getData().getNodeId()+",");
				
				if(index.getChildList()!=null&&index.getChildList().size()>0)
				{	
					buffer.append(iteratorTree(index));
				}
			}
		}
		
		buffer.append("
");
		
		returnbuffer.toString();
	}
	
	publicManyTreeNodegetRoot(){
		returnroot;
	}

	publicvoidsetRoot(ManyTreeNoderoot){
		this.root=root;
	}
	
	publicstaticvoidmain(String[]args)
	{
		List<TreeNode>treeNodes=newArrayList<TreeNode>();
			treeNodes.add(newTreeNode("系統許可權管理","root"));
			treeNodes.add(newTreeNode("用戶管理","系統許可權管理"));
			treeNodes.add(newTreeNode("角色管理","系統許可權管理"));
			treeNodes.add(newTreeNode("組管理","系統許可權管理"));
			treeNodes.add(newTreeNode("用戶菜單管理","系統許可權管理"));
			treeNodes.add(newTreeNode("角色菜單管理","系統許可權管理"));
			treeNodes.add(newTreeNode("用戶許可權管理","系統許可權管理"));
			treeNodes.add(newTreeNode("站內信","root"));
			treeNodes.add(newTreeNode("寫信","站內信"));
			treeNodes.add(newTreeNode("收信","站內信"));
			treeNodes.add(newTreeNode("草稿","站內信"));
			
			ManyNodeTreetree=newManyNodeTree();
			
			System.out.println(tree.iteratorTree(tree.createTree(treeNodes).getRoot()));
	}
	
}

『伍』 Java 多叉樹 遍歷

public class test {

private List<String[]> lists = new ArrayList<String[]>();
public test(){
lists.add(new String[]{"0","1"});
lists.add(new String[]{"0","2"});
lists.add(new String[]{"0","3"});
lists.add(new String[]{"3","4"});
lists.add(new String[]{"3","5"});
lists.add(new String[]{"3","6"});
lists.add(new String[]{"6","7"});
lists.add(new String[]{"6","8"});
}
public boolean testA(String s,String sysos){
boolean f = true;
for (int j = 0; j < lists.size(); j++) {
String[] str = lists.get(j);
if(str[0].equals(s)){
if(testA(str[1],sysos+s)){
f = false;
}
}
}
if(f){
System.out.println(sysos+s);
}
return f;
}

public static void main(String[] args){
test t = new test();
t.testA("0","");
}
}

『陸』 多叉樹怎麼用遞歸遍歷

給的是3叉樹，可以自己改MAX_

C

HILDREN_NUM 3 //三叉樹
輸入節點，然後分別建底下的各個孩子，注意，每個孩子都要求輸入數據，沒有則輸入0.反正建樹很煩

#include<stdio.h>
#include<malloc.h>
#include<math.h>
#include<conio.h>
#defineMAX_DEPTH4
#defineMAX_CHILDREN_NUM3//三叉樹

typedefstructtnode
{
intdata;
tnode**children,*parent;//parent域可不要
}tnode;

typedefstruct
{
tnode*ptr;
intcur;//cur記錄當前訪問到的孩子節點下標
boolvisited;//是否被訪問標記
}snode;

typedefstruct
{
snode*elem;
inttop;
}stack;

voidinitstack(stack*s)
{
s->elem=(snode*)malloc(
(int)pow(MAX_CHILDREN_NUM,MAX_DEPTH)*sizeof(snode));
s->top=0;
}

voidpop(stack*s,snode*e)
{
--s->top;
*e=s->elem[s->top];
}

voidpush(stack*s,snode*e)
{
s->elem[s->top]=*e;
++s->top;
}

voidcreate(tnode**t,tnode*parent)
{
intn;
scanf("%d",&n);
if(!n)
{
*t=NULL;
return;
}
else
{
*t=(tnode*)malloc(sizeof(tnode));
(*t)->data=n;
(*t)->parent=parent;//可不要
(*t)->children=(tnode**)malloc(MAX_CHILDREN_NUM*sizeof(tnode*));
for(n=0;n<MAX_CHILDREN_NUM;++n)
create(&(*t)->children[n],*t);
}
}

voidvisit(tnode*t)
{
printf("%5d",t->data);
}

voidpostorder1(tnode*t)
{
inti;
if(t)
{
for(i=0;i<MAX_CHILDREN_NUM;++i)
postorder1(t->children[i]);
visit(t);
}
}

voidpostorder2(tnode*t)
{//和前序遍歷基本相同，只是把訪問語句的執行由
//入棧時執行改為出棧時執行

stacks;
snodee;

initstack(&s);
e.ptr=t;
e.cur=0;
e.visited=false;
push(&s,&e);

while(s.top)
{
while(s.elem[s.top-1].ptr)
{
do
{
e.ptr=s.elem[s.top-1].ptr->children[s.elem[s.top-1].cur];
++s.elem[s.top-1].cur;
}while(!e.ptr&&s.elem[s.top-1].cur<MAX_CHILDREN_NUM);
e.cur=0;
e.visited=false;
push(&s,&e);
}
pop(&s,&e);

while(s.top&&s.elem[s.top-1].cur==MAX_CHILDREN_NUM)
{
if(!s.elem[s.top-1].visited)
{
visit(s.elem[s.top-1].ptr);
s.elem[s.top-1].visited=true;
}
pop(&s,&e);
}
}
}

voidmain()
{
tnode*T;
create(&T,NULL);
printf("
遞歸後序遍歷：");
postorder1(T);
printf("
非遞歸後序遍歷：");
postorder2(T);
}

『柒』 多叉樹的深度遍歷，要求用棧實現遍歷，並要求制定結束條件，以多叉樹村詞條

ude<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include<conio.h>
#define DataType int
#define MAXSIZE 100
//#define NULL 0 //無需定義
typedef struct
{ DataType data[MAXSIZE];
int top;
}SeqStack;

SeqStack * init_SeqStack(SeqStack *&s) //初始化棧
{
s=(SeqStack *)malloc(sizeof(SeqStack));
if(!s)
{printf("空間不足\n");
return NULL;}
else
{s->top=-1;
return s;}
}

int empty_SeqStack(SeqStack *s) //判棧空
{ if(s->top==-1)
return 1;
else return 0;
}

int push_SeqStack(SeqStack *s,DataType x) //入棧
{ if(s->top==MAXSIZE-1)
return 0;
else

}

int pop_SeqStack(SeqStack *s,DataType *x) //出棧
{if(s->top==-1)
return 0;
else
{*x=s->data[s->top];
s->top--;
return 1;
}
}

DataType top_SeqStack(SeqStack *s) //取棧頂元素
{
if(empty_SeqStack(s))
return 0;
else
return s->data[s->top];
}

int print(SeqStack *s)
{ int i;
printf("當前棧中元素：\n");
for(i=s->top;i>=0;i--)
printf("%3d",s->data[i]);
printf("\n");
return 0;
}

int main()
{ SeqStack *L;
int n;
int num;
int m;
init_SeqStack(L);
printf("初始化完成\n");
printf("棧空：%d\n",empty_SeqStack(L));
printf("請輸入入棧元素個數:\n");
scanf("%d",&n);
printf("請輸入要入棧的%d個元素：\n");

for(int i=0;i<n;i++)
{ scanf("%d",&num);
push_SeqStack(L,num);
}
print(L);
printf("棧頂元素:%d\n",top_SeqStack(L));
printf("請輸入要出棧的元素個數：%d\n",n);
scanf("%d",&n);
printf("以此出棧的%d個元素:\n",n);
for (int i=0; i<n;i++) //加int
{pop_SeqStack(L,&m);
printf("%3d",m);
}
printf("\n");
print(L);
printf("棧頂元素:%d\n",top_SeqStack(L));
return 0;
}
另外,虛機團上產品團購,超級便宜

『捌』 java實現多叉樹的某層遍歷，求思路。一棵多叉樹有M層，子節點數不定，要求列印輸出第N層的節點。說

樹的遍歷多用遞歸，從根節點出發，對子數進行逐級迭代

/**
*以p為根向下訪問x層
*@paramlayer存儲結果
*/
publicvoidlayerX(List<Node>layer,Nodep,intx){
if(p!=null){
//至訪問層的節點
if(x==1){
layer.add(p);
}

//繼續遞歸訪問以位元組點為(參照)根訪問x-1層
Node[]c=p.getChildren();
if(c!=null){
for(Noden:c){
layerX(layer,n,x-1);
}
}
}
}

classNode{
privateStringname;//節點名稱
privateNode[]children;//子節點

publicNode(Stringname,Node[]children){
this.name=name;
this.children=children;
}
//getter，setter
}

『玖』 求多叉樹的後序遍歷代碼。。。

給的是3叉樹，可以自己改MAX_CHILDREN_NUM 3 //三叉樹
輸入節點，然後分別建底下的各個孩子，注意，每個孩子都要求輸入數據，沒有則輸入0.反正建樹很煩

#include <stdio.h>
#include <malloc.h>
#include <math.h>
#include <conio.h>
#define MAX_DEPTH 4
#define MAX_CHILDREN_NUM 3 //三叉樹

typedef struct tnode
{
int data;
tnode **children, *parent; //parent域可不要
}tnode;

typedef struct
{
tnode* ptr;
int cur;//cur記錄當前訪問到的孩子節點下標
bool visited; //是否被訪問標記
}snode;

typedef struct
{
snode *elem;
int top;
}stack;

void initstack(stack *s)
{
s->elem=(snode*)malloc(
(int)pow(MAX_CHILDREN_NUM,MAX_DEPTH)*sizeof(snode));
s->top = 0;
}

void pop(stack *s, snode *e)
{
--s->top;
*e = s->elem[s->top];
}

void push(stack *s, snode *e)
{
s->elem[s->top] = *e;
++s->top;
}

void create(tnode **t, tnode *parent)
{
int n;
scanf("%d", &n);
if(!n)
{
*t = NULL;
return;
}
else
{
*t = (tnode*)malloc(sizeof(tnode));
(*t)->data = n;
(*t)->parent = parent;//可不要
(*t)->children = (tnode**)malloc(MAX_CHILDREN_NUM*sizeof(tnode*));
for(n = 0; n < MAX_CHILDREN_NUM; ++n)
create(&(*t)->children[n], *t);
}
}

void visit(tnode *t)
{
printf("%5d", t->data);
}

void postorder1(tnode *t)
{
int i;
if(t)
{
for(i = 0; i < MAX_CHILDREN_NUM; ++i)
postorder1(t->children[i]);
visit(t);
}
}

void postorder2(tnode *t)
{// 和前序遍歷基本相同，只是把訪問語句的執行由
// 入棧時執行改為出棧時執行

stack s;
snode e;

initstack(&s);
e.ptr = t;
e.cur = 0;
e.visited = false;
push(&s, &e);

while(s.top)
{
while(s.elem[s.top-1].ptr)
{
do
{
e.ptr = s.elem[s.top-1].ptr->children[s.elem[s.top-1].cur];
++s.elem[s.top-1].cur;
}while(!e.ptr && s.elem[s.top-1].cur<MAX_CHILDREN_NUM);
e.cur = 0;
e.visited = false;
push(&s, &e);
}
pop(&s,&e);

while(s.top && s.elem[s.top-1].cur == MAX_CHILDREN_NUM)
{
if(!s.elem[s.top-1].visited)
{
visit(s.elem[s.top-1].ptr);
s.elem[s.top-1].visited = true;
}
pop(&s, &e);
}
}
}

void main()
{
tnode *T;
create(&T, NULL);
printf("\n遞歸後序遍歷：");
postorder1(T);
printf("\n非遞歸後序遍歷：");
postorder2(T);
}

『拾』 用java建立二叉樹

數據結構的教材里有，
建立兩個類就應該可以了。

一個是樹的節點，一個是樹，這個是我以前編寫的寬度優先遍歷的樹的構建和遍歷，希望對你有幫助。文件名是：Tree.java

import java.util.ArrayList;

// 樹的一個節點
class TreeNode {

Object _value = null; // 他的值
TreeNode _parent = null; // 他的父節點，根節點沒有PARENT
ArrayList _childList = new ArrayList(); // 他的孩子節點

public TreeNode( Object value, TreeNode parent ){
this._parent = parent;
this._value = value;
}

public TreeNode getParent(){
return _parent;
}

public String toString() {
return _value.toString();
}
}

public class Tree {

// 給出寬度優先遍歷的值數組，構建出一棵多叉樹
// null 值表示一個層次的結束
// "|" 表示一個層次中一個父親節點的孩子輸入結束
// 如：給定下面的值數組：
// { "root", null, "left", "right", null }
// 則構建出一個根節點，帶有兩個孩子("left","right")的樹
public Tree( Object[] values ){
// 創建根
_root = new TreeNode( values[0], null );

// 創建下面的子節點
TreeNode currentParent = _root; // 用於待創建節點的父親
//TreeNode nextParent = null;
int currentChildIndex = 0; // 表示 currentParent 是他的父親的第幾個兒子
//TreeNode lastNode = null; // 最後一個創建出來的TreeNode，用於找到他的父親
for ( int i = 2; i < values.length; i++ ){

// 如果null ,表示下一個節點的父親是當前節點的父親的第一個孩子節點
if ( values[i] == null ){
currentParent = (TreeNode)currentParent._childList.get(0);
currentChildIndex = 0;
continue;
}

// 表示一個父節點的所有孩子輸入完畢
if ( values[i].equals("|") ){
if ( currentChildIndex+1 < currentParent._childList.size() ){
currentChildIndex++;
currentParent = (TreeNode)currentParent._parent._childList.get(currentChildIndex);
}
continue;
}

TreeNode child = createChildNode( currentParent, values[i] );
}
}

TreeNode _root = null;

public TreeNode getRoot(){
return _root;
}
/**
// 按寬度優先遍歷，列印出parent子樹所有的節點
private void printSteps( TreeNode parent, int currentDepth ){
for ( int i = 0; i < parent._childList.size(); i++ ){
TreeNode child = (TreeNode)parent._childList.get(i);
System.out.println(currentDepth+":"+child);
}
if ( parent._childList.size() != 0 ) System.out.println(""+null);// 為了避免葉子節點也會列印null

//列印 parent 同層的節點的孩子
if ( parent._parent != null ){ // 不是root
int i = 1;
while ( i < parent._parent._childList.size() ){// parent 的父親還有孩子
TreeNode current = (TreeNode)parent._parent._childList.get(i);
printSteps( current, currentDepth );
i++;
}
}

// 遞歸調用，列印所有節點
for ( int i = 0; i < parent._childList.size(); i++ ){
TreeNode child = (TreeNode)parent._childList.get(i);
printSteps( child, currentDepth+1 );
}

}

// 按寬度優先遍歷，列印出parent子樹所有的節點
public void printSteps(){
System.out.println(""+_root);
System.out.println(""+null);

printSteps(_root, 1 );
}**/

// 將給定的值做為 parent 的孩子，構建節點
private TreeNode createChildNode( TreeNode parent, Object value ){
TreeNode child = new TreeNode( value , parent );
parent._childList.add( child );
return child;
}

public static void main(String[] args) {

Tree tree = new Tree( new Object[]{ "root", null,
"left", "right", null,
"l1","l2","l3", "|", "r1","r2",null } );
//tree.printSteps();

System.out.println(""+ ( (TreeNode)tree.getRoot()._childList.get(0) )._childList.get(0) );
System.out.println(""+ ( (TreeNode)tree.getRoot()._childList.get(0) )._childList.get(1) );
System.out.println(""+ ( (TreeNode)tree.getRoot()._childList.get(0) )._childList.get(2) );

System.out.println(""+ ( (TreeNode)tree.getRoot()._childList.get(1) )._childList.get(0) );
System.out.println(""+ ( (TreeNode)tree.getRoot()._childList.get(1) )._childList.get(1) );

}

}