二叉樹java,二叉樹java實現

本文目錄一覽：

• 1、java 由字符串構成的二叉樹
• 2、java如何創建一顆二叉樹
• 3、用java實現二叉樹
• 4、用java怎麼構造一個二叉樹？
• 5、用java怎麼構造一個二叉樹呢？
• 6、java構建二叉樹算法

java 由字符串構成的二叉樹

java構造二叉樹，可以通過鏈表來構造，如下代碼：

public class BinTree {public final static int MAX=40;BinTree []elements = new BinTree[MAX];//層次遍歷時保存各個節點 int front;//層次遍歷時隊首 int rear;//層次遍歷時隊尾private Object data; //數據元數private BinTree left,right; //指向左,右孩子結點的鏈public BinTree(){}public BinTree(Object data){ //構造有值結點 this.data = data; left = right = null;}public BinTree(Object data,BinTree left,BinTree right){ //構造有值結點 this.data = data; this.left = left; this.right = right;}public String toString(){ return data.toString();}//前序遍歷二叉樹public static void preOrder(BinTree parent){ if(parent == null) return; System.out.print(parent.data+” “); preOrder(parent.left); preOrder(parent.right);}//中序遍歷二叉樹public void inOrder(BinTree parent){ if(parent == null) return; inOrder(parent.left); System.out.print(parent.data+” “); inOrder(parent.right);}//後序遍歷二叉樹public void postOrder(BinTree parent){ if(parent == null) return; postOrder(parent.left); postOrder(parent.right); System.out.print(parent.data+” “);}// 層次遍歷二叉樹 public void LayerOrder(BinTree parent){ elements[0]=parent; front=0;rear=1; while(frontrear) { try { if(elements[front].data!=null) { System.out.print(elements[front].data + ” “); if(elements[front].left!=null) elements[rear++]=elements[front].left; if(elements[front].right!=null) elements[rear++]=elements[front].right; front++; } }catch(Exception e){break;} }}//返回樹的葉節點個數public int leaves(){ if(this == null) return 0; if(left == nullright == null) return 1; return (left == null ? 0 : left.leaves())+(right == null ? 0 : right.leaves());}//結果返回樹的高度public int height(){ int heightOfTree; if(this == null) return -1; int leftHeight = (left == null ? 0 : left.height()); int rightHeight = (right == null ? 0 : right.height()); heightOfTree = leftHeightrightHeight?rightHeight:leftHeight; return 1 + heightOfTree;}//如果對象不在樹中,結果返回-1;否則結果返回該對象在樹中所處的層次,規定根節點為第一層public int level(Object object){ int levelInTree; if(this == null) return -1; if(object == data) return 1;//規定根節點為第一層 int leftLevel = (left == null?-1:left.level(object)); int rightLevel = (right == null?-1:right.level(object)); if(leftLevel0rightLevel0) return -1; levelInTree = leftLevelrightLevel?rightLevel:leftLevel; return 1+levelInTree; }//將樹中的每個節點的孩子對換位置public void reflect(){ if(this == null) return; if(left != null) left.reflect(); if(right != null) right.reflect(); BinTree temp = left; left = right; right = temp;}// 將樹中的所有節點移走,並輸出移走的節點public void defoliate(){ if(this == null) return; //若本節點是葉節點，則將其移走 if(left==nullright == null) { System.out.print(this + ” “); data = null; return; } //移走左子樹若其存在 if(left!=null){ left.defoliate(); left = null; } //移走本節點，放在中間表示中跟移走… String innerNode += this + ” “; data = null; //移走右子樹若其存在 if(right!=null){ right.defoliate(); right = null; }} /*** @param args*/public static void main(String[] args) { // TODO Auto-generated method stub BinTree e = new BinTree(“E”); BinTree g = new BinTree(“G”); BinTree h = new BinTree(“H”); BinTree i = new BinTree(“I”); BinTree d = new BinTree(“D”,null,g); BinTree f = new BinTree(“F”,h,i); BinTree b = new BinTree(“B”,d,e); BinTree c = new BinTree(“C”,f,null); BinTree tree = new BinTree(“A”,b,c); System.out.println(“前序遍歷二叉樹結果: “); tree.preOrder(tree); System.out.println(); System.out.println(“中序遍歷二叉樹結果: “); tree.inOrder(tree); System.out.println(); System.out.println(“後序遍歷二叉樹結果: “); tree.postOrder(tree); System.out.println(); System.out.println(“層次遍歷二叉樹結果: “); tree.LayerOrder(tree); System.out.println(); System.out.println(“F所在的層次: “+tree.level(“F”)); System.out.println(“這棵二叉樹的高度: “+tree.height()); System.out.println(“————————————–“); tree.reflect(); System.out.println(“交換每個節點的孩子節點後……”); System.out.println(“前序遍歷二叉樹結果: “); tree.preOrder(tree); System.out.println(); System.out.println(“中序遍歷二叉樹結果: “); tree.inOrder(tree); System.out.println(); System.out.println(“後序遍歷二叉樹結果: “); tree.postOrder(tree); System.out.println(); System.out.println(“層次遍歷二叉樹結果: “); tree.LayerOrder(tree); System.out.println(); System.out.println(“F所在的層次: “+tree.level(“F”)); System.out.println(“這棵二叉樹的高度: “+tree.height());

java如何創建一顆二叉樹

計算機科學中，二叉樹是每個結點最多有兩個子樹的有序樹。通常子樹的根被稱作“左子樹”（left

subtree）和“右子樹”（right

subtree）。二叉樹常被用作二叉查找樹和二叉堆或是二叉排序樹。

二叉樹的每個結點至多只有二棵子樹(不存在度大於2的結點)，二叉樹的子樹有左右之分，次序不能顛倒。二叉樹的第i層至多有2的

i

-1次方個結點；深度為k的二叉樹至多有2^(k)

-1個結點；對任何一棵二叉樹T，如果其終端結點數(即葉子結點數)為n0，度為2的結點數為n2，則n0

=

n2

+

1。

樹是由一個或多個結點組成的有限集合，其中：

⒈必有一個特定的稱為根(ROOT)的結點；

二叉樹

⒉剩下的結點被分成n=0個互不相交的集合T1、T2、……Tn，而且，

這些集合的每一個又都是樹。樹T1、T2、……Tn被稱作根的子樹(Subtree)。

樹的遞歸定義如下：（1）至少有一個結點（稱為根）（2）其它是互不相交的子樹

1.樹的度——也即是寬度，簡單地說，就是結點的分支數。以組成該樹各結點中最大的度作為該樹的度，如上圖的樹，其度為2;樹中度為零的結點稱為葉結點或終端結點。樹中度不為零的結點稱為分枝結點或非終端結點。除根結點外的分枝結點統稱為內部結點。

2.樹的深度——組成該樹各結點的最大層次。

3.森林——指若干棵互不相交的樹的集合，如上圖，去掉根結點A，其原來的二棵子樹T1、T2、T3的集合{T1,T2,T3}就為森林；

4.有序樹——指樹中同層結點從左到右有次序排列，它們之間的次序不能互換，這樣的樹稱為有序樹，否則稱為無序樹。

樹的表示

樹的表示方法有許多，常用的方法是用括號：先將根結點放入一對圓括號中，然後把它的子樹由左至右的順序放入括號中，而對子樹也採用同樣的方法處理；同層子樹與它的根結點用圓括號括起來，同層子樹之間用逗號隔開，最後用閉括號括起來。如右圖可寫成如下形式：

二叉樹

(a(

b(d,e),

c(

f(

,g(h,i)

),

)))

用java實現二叉樹

我有很多個(假設10萬個)數據要保存起來，以後還需要從保存的這些數據中檢索是否存在某

個數據，（我想說出二叉樹的好處，該怎麼說呢？那就是說別人的缺點），假如存在數組中，

那麼，碰巧要找的數字位於99999那個地方，那查找的速度將很慢，因為要從第1個依次往

後取，取出來後進行比較。平衡二叉樹（構建平衡二叉樹需要先排序，我們這裡就不作考慮

了）可以很好地解決這個問題，但二叉樹的遍歷（前序，中序，後序）效率要比數組低很多，

public class Node {

public int value;

public Node left;

public Node right;

public void store(intvalue)

right.value=value;

}

else

{

right.store(value);

}

}

}

public boolean find(intvalue)

{

System.out.println(“happen” +this.value);

if(value ==this.value)

{

return true;

}

else if(valuethis.value)

{

if(right ==null)returnfalse;

return right.find(value);

}else

{

if(left ==null)returnfalse;

return left.find(value);

}

}

public void preList()

{

System.out.print(this.value+ “,”);

if(left!=null)left.preList();

if(right!=null) right.preList();

}

public void middleList()

{

if(left!=null)left.preList();

System.out.print(this.value+ “,”);

if(right!=null)right.preList();

}

public void afterList()

{

if(left!=null)left.preList();

if(right!=null)right.preList();

System.out.print(this.value+ “,”);

}

public static voidmain(String [] args)

{

int [] data =new int[20];

for(inti=0;idata.length;i++)

{

data[i] = (int)(Math.random()*100)+ 1;

System.out.print(data[i] +”,”);

}

System.out.println();

Node root = new Node();

root.value = data[0];

for(inti=1;idata.length;i++)

{

root.store(data[i]);

}

root.find(data[19]);

root.preList();

System.out.println();

root.middleList();

System.out.println();

root.afterList();

}

}

用java怎麼構造一個二叉樹？

二叉樹的相關操作，包括創建，中序、先序、後序（遞歸和非遞歸），其中重點的是java在先序創建二叉樹和後序非遞歸遍歷的的實現。

package com.algorithm.tree;

import java.io.File;

import java.io.FileNotFoundException;

import java.util.Queue;

import java.util.Scanner;

import java.util.Stack;

import java.util.concurrent.LinkedBlockingQueue;

public class Tree {

private Node root;

public Tree() {

}

public Tree(Node root) {

this.root = root;

}

//創建二叉樹

public void buildTree() {

Scanner scn = null;

try {

scn = new Scanner(new File(“input.txt”));

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

root = createTree(root,scn);

}

//先序遍歷創建二叉樹

private Node createTree(Node node,Scanner scn) {

String temp = scn.next();

if (temp.trim().equals(“#”)) {

return null;

} else {

node = new Node((T)temp);

node.setLeft(createTree(node.getLeft(), scn));

node.setRight(createTree(node.getRight(), scn));

return node;

}

}

//中序遍歷(遞歸)

public void inOrderTraverse() {

inOrderTraverse(root);

}

public void inOrderTraverse(Node node) {

if (node != null) {

inOrderTraverse(node.getLeft());

System.out.println(node.getValue());

inOrderTraverse(node.getRight());

}

}

//中序遍歷(非遞歸)

public void nrInOrderTraverse() {

StackNode stack = new StackNode();

Node node = root;

while (node != null || !stack.isEmpty()) {

while (node != null) {

stack.push(node);

node = node.getLeft();

}

node = stack.pop();

System.out.println(node.getValue());

node = node.getRight();

}

}

//先序遍歷(遞歸)

public void preOrderTraverse() {

preOrderTraverse(root);

}

public void preOrderTraverse(Node node) {

if (node != null) {

System.out.println(node.getValue());

preOrderTraverse(node.getLeft());

preOrderTraverse(node.getRight());

}

}

//先序遍歷（非遞歸）

public void nrPreOrderTraverse() {

StackNode stack = new StackNode();

Node node = root;

while (node != null || !stack.isEmpty()) {

while (node != null) {

System.out.println(node.getValue());

stack.push(node);

node = node.getLeft();

}

node = stack.pop();

node = node.getRight();

}

}

//後序遍歷(遞歸)

public void postOrderTraverse() {

postOrderTraverse(root);

}

public void postOrderTraverse(Node node) {

if (node != null) {

postOrderTraverse(node.getLeft());

postOrderTraverse(node.getRight());

System.out.println(node.getValue());

}

}

//後續遍歷(非遞歸)

public void nrPostOrderTraverse() {

StackNode stack = new StackNode();

Node node = root;

Node preNode = null;//表示最近一次訪問的節點

while (node != null || !stack.isEmpty()) {

while (node != null) {

stack.push(node);

node = node.getLeft();

}

node = stack.peek();

if (node.getRight() == null || node.getRight() == preNode) {

System.out.println(node.getValue());

node = stack.pop();

preNode = node;

node = null;

} else {

node = node.getRight();

}

}

}

//按層次遍歷

public void levelTraverse() {

levelTraverse(root);

}

public void levelTraverse(Node node) {

QueueNode queue = new LinkedBlockingQueueNode();

queue.add(node);

while (!queue.isEmpty()) {

Node temp = queue.poll();

if (temp != null) {

System.out.println(temp.getValue());

queue.add(temp.getLeft());

queue.add(temp.getRight());

}

}

}

}

//樹的節點

class Node {

private Node left;

private Node right;

private T value;

public Node() {

}

public Node(Node left,Node right,T value) {

this.left = left;

this.right = right;

this.value = value;

}

public Node(T value) {

this(null,null,value);

}

public Node getLeft() {

return left;

}

public void setLeft(Node left) {

this.left = left;

}

public Node getRight() {

return right;

}

public void setRight(Node right) {

this.right = right;

}

public T getValue() {

return value;

}

public void setValue(T value) {

this.value = value;

}

}

測試代碼：

package com.algorithm.tree;

public class TreeTest {

/**

* @param args

*/

public static void main(String[] args) {

Tree tree = new Tree();

tree.buildTree();

System.out.println(“中序遍歷”);

tree.inOrderTraverse();

tree.nrInOrderTraverse();

System.out.println(“後續遍歷”);

//tree.nrPostOrderTraverse();

tree.postOrderTraverse();

tree.nrPostOrderTraverse();

System.out.println(“先序遍歷”);

tree.preOrderTraverse();

tree.nrPreOrderTraverse();

//

}

}

用java怎麼構造一個二叉樹呢？

java構造二叉樹，可以通過鏈表來構造，如下代碼：

public class BinTree {

public final static int MAX=40;

BinTree []elements = new BinTree[MAX];//層次遍歷時保存各個節點

    int front;//層次遍歷時隊首

    int rear;//層次遍歷時隊尾

private Object data; //數據元數

private BinTree left,right; //指向左,右孩子結點的鏈

public BinTree()

{

}

public BinTree(Object data)

{ //構造有值結點

   this.data = data;

   left = right = null;

}

public BinTree(Object data,BinTree left,BinTree right)

{ //構造有值結點

   this.data = data;

   this.left = left;

   this.right = right;

}

public String toString()

{

   return data.toString();

}

//前序遍歷二叉樹

public static void preOrder(BinTree parent){ 

     if(parent == null)

      return;

     System.out.print(parent.data+” “);

     preOrder(parent.left);

     preOrder(parent.right);

}

//中序遍歷二叉樹

public void inOrder(BinTree parent){

   if(parent == null)

      return;

   inOrder(parent.left);

   System.out.print(parent.data+” “);

     inOrder(parent.right);

}

//後序遍歷二叉樹

public void postOrder(BinTree parent){

   if(parent == null)

    return;

   postOrder(parent.left);

   postOrder(parent.right);

   System.out.print(parent.data+” “);

}

// 層次遍歷二叉樹 

public void LayerOrder(BinTree parent)

{ 

     elements[0]=parent;

     front=0;rear=1;

   while(frontrear)

   {

    try

    {

        if(elements[front].data!=null)

        {

           System.out.print(elements[front].data + ” “);

           if(elements[front].left!=null)

          elements[rear++]=elements[front].left;

           if(elements[front].right!=null)

          elements[rear++]=elements[front].right;

           front++;

        }

    }catch(Exception e){break;}

   }

}

//返回樹的葉節點個數

public int leaves()

{

   if(this == null)

    return 0;

   if(left == nullright == null)

    return 1;

   return (left == null ? 0 : left.leaves())+(right == null ? 0 : right.leaves());

}

//結果返回樹的高度

public int height()

{

   int heightOfTree;

   if(this == null)

    return -1;

   int leftHeight = (left == null ? 0 : left.height());

   int rightHeight = (right == null ? 0 : right.height());

   heightOfTree = leftHeightrightHeight?rightHeight:leftHeight;

   return 1 + heightOfTree;

}

//如果對象不在樹中,結果返回-1;否則結果返回該對象在樹中所處的層次,規定根節點為第一層

public int level(Object object)

{

   int levelInTree;

   if(this == null)

    return -1;

   if(object == data)

    return 1;//規定根節點為第一層

   int leftLevel = (left == null?-1:left.level(object));

   int rightLevel = (right == null?-1:right.level(object));

   if(leftLevel0rightLevel0)

    return -1;

   levelInTree = leftLevelrightLevel?rightLevel:leftLevel;

   return 1+levelInTree;

}

//將樹中的每個節點的孩子對換位置

public void reflect()

{

   if(this == null)

    return;

   if(left != null)

    left.reflect();

   if(right != null)

    right.reflect();

   BinTree temp = left;

   left = right;

   right = temp;

}

// 將樹中的所有節點移走,並輸出移走的節點

public void defoliate()

{

   if(this == null)

    return;

   //若本節點是葉節點，則將其移走

   if(left==nullright == null)

   {

    System.out.print(this + ” “);

    data = null;

    return;

   }

   //移走左子樹若其存在

   if(left!=null){

    left.defoliate();

    left = null;

   }

   //移走本節點，放在中間表示中跟移走…

   String innerNode += this + ” “;

   data = null;

   //移走右子樹若其存在

   if(right!=null){

    right.defoliate();

    right = null;

   }

}

   /**

* @param args

*/

public static void main(String[] args) {

   // TODO Auto-generated method stub

   BinTree e = new BinTree(“E”);

   BinTree g = new BinTree(“G”);

   BinTree h = new BinTree(“H”);

   BinTree i = new BinTree(“I”);

   BinTree d = new BinTree(“D”,null,g);

   BinTree f = new BinTree(“F”,h,i);

   BinTree b = new BinTree(“B”,d,e);

   BinTree c = new BinTree(“C”,f,null);

   BinTree tree = new BinTree(“A”,b,c);

        System.out.println(“前序遍歷二叉樹結果: “);

        tree.preOrder(tree);

        System.out.println();

        System.out.println(“中序遍歷二叉樹結果: “);

        tree.inOrder(tree);

        System.out.println();

        System.out.println(“後序遍歷二叉樹結果: “);

        tree.postOrder(tree);

        System.out.println();

      System.out.println(“層次遍歷二叉樹結果: “);

     tree.LayerOrder(tree);

     System.out.println();

        System.out.println(“F所在的層次: “+tree.level(“F”));

        System.out.println(“這棵二叉樹的高度: “+tree.height());

         System.out.println(“————————————–“);

         tree.reflect();

          System.out.println(“交換每個節點的孩子節點後……”);

          System.out.println(“前序遍歷二叉樹結果: “);

        tree.preOrder(tree);

        System.out.println();

        System.out.println(“中序遍歷二叉樹結果: “);

        tree.inOrder(tree);

        System.out.println();

        System.out.println(“後序遍歷二叉樹結果: “);

        tree.postOrder(tree);

        System.out.println();

      System.out.println(“層次遍歷二叉樹結果: “);

     tree.LayerOrder(tree);

     System.out.println();

        System.out.println(“F所在的層次: “+tree.level(“F”));

        System.out.println(“這棵二叉樹的高度: “+tree.height());

}

java構建二叉樹算法

//******************************************************************************************************//

//*****本程序包括簡單的二叉樹類的實現和前序,中序,後序,層次遍歷二叉樹算法,*******//

//******以及確定二叉樹的高度,制定對象在樹中的所處層次以及將樹中的左右***********//

//******孩子節點對換位置,返回葉子節點個數刪除葉子節點,並輸出所刪除的葉子節點**//

//*******************************CopyRight By phoenix*******************************************//

//************************************Jan 12,2008*************************************************//

//****************************************************************************************************//

public class BinTree {

public final static int MAX=40;

private Object data; //數據元數

private BinTree left,right; //指向左,右孩子結點的鏈

BinTree []elements = new BinTree[MAX];//層次遍歷時保存各個節點

int front;//層次遍歷時隊首

int rear;//層次遍歷時隊尾

public BinTree()

{

}

public BinTree(Object data)

{ //構造有值結點

this.data = data;

left = right = null;

}

public BinTree(Object data,BinTree left,BinTree right)

{ //構造有值結點

this.data = data;

this.left = left;

this.right = right;

}

public String toString()

{

return data.toString();

}//前序遍歷二叉樹

public static void preOrder(BinTree parent){

if(parent == null)

return;

System.out.print(parent.data+” “);

preOrder(parent.left);

preOrder(parent.right);

}//中序遍歷二叉樹

public void inOrder(BinTree parent){

if(parent == null)

return;

inOrder(parent.left);

System.out.print(parent.data+” “);

inOrder(parent.right);

}//後序遍歷二叉樹

public void postOrder(BinTree parent){

if(parent == null)

return;

postOrder(parent.left);

postOrder(parent.right);

System.out.print(parent.data+” “);

}// 層次遍歷二叉樹

public void LayerOrder(BinTree parent)

{

elements[0]=parent;

front=0;rear=1;

while(frontrear)

{

try

{

if(elements[front].data!=null)

{

System.out.print(elements[front].data + ” “);

if(elements[front].left!=null)

elements[rear++]=elements[front].left;

if(elements[front].right!=null)

elements[rear++]=elements[front].right;

front++;

}

}catch(Exception e){break;}

}

}//返回樹的葉節點個數

public int leaves()

{

if(this == null)

return 0;

if(left == nullright == null)

return 1;

return (left == null ? 0 : left.leaves())+(right == null ? 0 : right.leaves());

}//結果返回樹的高度

public int height()

{

int heightOfTree;

if(this == null)

return -1;

int leftHeight = (left == null ? 0 : left.height());

int rightHeight = (right == null ? 0 : right.height());

heightOfTree = leftHeightrightHeight?rightHeight:leftHeight;

return 1 + heightOfTree;

}

//如果對象不在樹中,結果返回-1;否則結果返回該對象在樹中所處的層次,規定根節點為第一層

public int level(Object object)

{

int levelInTree;

if(this == null)

return -1;

if(object == data)

return 1;//規定根節點為第一層

int leftLevel = (left == null?-1:left.level(object));

int rightLevel = (right == null?-1:right.level(object));

if(leftLevel0rightLevel0)

return -1;

levelInTree = leftLevelrightLevel?rightLevel:leftLevel;

return 1+levelInTree;

}

//將樹中的每個節點的孩子對換位置

public void reflect()

{

if(this == null)

return;

if(left != null)

left.reflect();

if(right != null)

right.reflect();

BinTree temp = left;

left = right;

right = temp;

}// 將樹中的所有節點移走,並輸出移走的節點

public void defoliate()

{

String innerNode = “”;

if(this == null)

return;

//若本節點是葉節點，則將其移走

if(left==nullright == null)

{

System.out.print(this + ” “);

data = null;

return;

}

//移走左子樹若其存在

if(left!=null){

left.defoliate();

left = null;

}

//移走本節點，放在中間表示中跟移走…

innerNode += this + ” “;

data = null;

//移走右子樹若其存在

if(right!=null){

right.defoliate();

right = null;

}

}

/**

* @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

BinTree e = new BinTree(“E”);

BinTree g = new BinTree(“G”);

BinTree h = new BinTree(“H”);

BinTree i = new BinTree(“I”);

BinTree d = new BinTree(“D”,null,g);

BinTree f = new BinTree(“F”,h,i);

BinTree b = new BinTree(“B”,d,e);

BinTree c = new BinTree(“C”,f,null);

BinTree tree = new BinTree(“A”,b,c);

System.out.println(“前序遍歷二叉樹結果: “);

tree.preOrder(tree);

System.out.println();

System.out.println(“中序遍歷二叉樹結果: “);

tree.inOrder(tree);

System.out.println();

System.out.println(“後序遍歷二叉樹結果: “);

tree.postOrder(tree);

System.out.println();

System.out.println(“層次遍歷二叉樹結果: “);

tree.LayerOrder(tree);

System.out.println();

System.out.println(“F所在的層次: “+tree.level(“F”));

System.out.println(“這棵二叉樹的高度: “+tree.height());

System.out.println(“————————————–“);

tree.reflect();

System.out.println(“交換每個節點的孩子節點後……”);

System.out.println(“前序遍歷二叉樹結果: “);

tree.preOrder(tree);

System.out.println();

System.out.println(“中序遍歷二叉樹結果: “);

tree.inOrder(tree);

System.out.println();

System.out.println(“後序遍歷二叉樹結果: “);

tree.postOrder(tree);

System.out.println();

System.out.println(“層次遍歷二叉樹結果: “);

tree.LayerOrder(tree);

System.out.println();

System.out.println(“F所在的層次: “+tree.level(“F”));

System.out.println(“這棵二叉樹的高度: “+tree.height());

}