树的基本操作java版

看了一下树的定义，一些基本的操作，遍历，获取节点数，获取深度等等。。这里参考了西电版的数据结构，基本用的都是递归实现的。

很多说明代码中都有，每个方法我都测了一下，这里我把节点类BTreeNode作为内部类放到了BTree中，方便一下。其实可以拿出来。还有我用的是二叉链表实现的树的存储,因为java 不能将函数（方法）作为参数传递，所以将visit()方法封装到了Visit类中，将Visit类对象作为参数传递

BTree.java

 package com.gxf.tree;

 /**
  * 定义数的属性和一些基本操作
  * @author Administrator
  *
  */
 public class BTree {
     /**
      * 树节点类
      * 这里用二叉链表，存储
      * @author Administrator
      *
      */
     class BTreeNode{
         private Object data;
         private BTreeNode lchild;
         private BTreeNode rchild;

         public BTreeNode(){
             lchild = null;
             rchild = null;
         }
         public void setData(Object data){
             this.data = data;
         }
         public void setLchild(BTreeNode lchild){
             this.lchild = lchild;
         }
         public void setRchild(BTreeNode rchild){
             this.rchild = rchild;
         }
         public Object getData(){
             return data;
         }
     }
     //下面是二叉树的一些属性
     private Object array[];//用数组保存所有树节点的数据
     private BTreeNode root;//根节点
     private Visit visit = new Visit();//java 不能将函数作为函数的参数，用一个类封装方法

     /**
      * 构造一棵树，指向根节点
      * @param array
      */
     public BTree(Object array[]){
         this.array = array;
         root = build(1);
     }

     /**
      * 根据成员变量array[]递归构造一棵树
      * 构造左子树、右子树
      * @return
      */
     public BTreeNode build(int i){
         int n = array.length;

         if(i <= n){//i在数组内，说明可以构造一个以array[i]为根节点的子树
             BTreeNode treeNode = new BTreeNode();
             treeNode.setData(array[i - 1]);//设置根节点
             treeNode.setLchild(build(2 * i));//构造左子树
             treeNode.setRchild(build(2 * i + 1));//构造右子树

             return treeNode;
         }else{
             return null;
         }
     }
     /**
      * 获取树的所有节点的个数
      */
     public int getNodeNum(){
         return getNodeNum(root);
     }
     /**
      * 计算所有节点的个数
      * 递归实现，左子树个数 + 右子树个数 + 1
      * @param root
      * @return
      */
     public int getNodeNum(BTreeNode root){
         if(null == root)
             return 0;
         else
         {
             return getNodeNum(root.lchild) + getNodeNum(root.rchild) + 1;
         }

     }
     /**
      * 获取树的高度
      * @return
      */
     public int getDep(){
         return getDep(root);
     }
     /**
      * 获取树的高度
      * 递归获取左右子树的高度，返回最高的那个
      * root为空，返回0，说明为空树，高度为0
      * 如果不为空，左子树和右子树高度较大值 +1为树的高度
      * @param root
      * @return
      */
     public int getDep(BTreeNode root){
         if(null == root)
             return 0;//空树返回0，高度为0，也是函数的出口
         else{
             int max = getDep(root.lchild);//获取左子树的高度
             if(max < getDep(root.rchild))
                 max = getDep(root.rchild);//获取右子树高度，并和左子树比较

             return max + 1;//因为不为空树，树的高度为左右子树高度的最大值 + 1
         }

     }
     /**
      * 前序遍历
      */
     public void preOrder(){
         preOrder(root);
     }
     /**
      * 前序遍历树，先遍历根节点，在遍历左节点，右节点
      *
      * @param root
      */
     public void preOrder(BTreeNode root){
         if(null != root){
             visit.visit(root);
             preOrder(root.lchild);
             preOrder(root.rchild);
         }
     }
     /**
      * 中序遍历
      */
     public void inOrder(){
         inOrder(root);
     }
     /**
      * 中序遍历，县遍历左子树，根，最后遍历右子树
      * 递归实现
      * @param root
      */
     public void inOrder(BTreeNode root){
         if(null != root)
         {
             inOrder(root.lchild);
             visit.visit(root);
             inOrder(root.rchild);
         }
     }
     /**
      * 后序遍历
      */
     public void postOrder(){
         postOrder(root);
     }
     /**
      * 后序遍历，先遍历左子树，右子树和根节点
      * 这也用递归实现
      * @param root
      */
     public void postOrder(BTreeNode root){
         if(null != root){//这里可以看成递归的出口
             postOrder(root.lchild);
             postOrder(root.rchild);
             visit.visit(root);
         }
     }

 }

Visit.java

 package com.gxf.tree;

 import com.gxf.tree.BTree.BTreeNode;

 public class Visit {
     public void visit(BTreeNode node){
         System.out.print(node.getData() + " ");
     }
     public void printLine(){
         System.out.println();
     }
 }

Test.java

 package com.gxf.tree;

 public class Test {

     public static void main(String[] args) {
         Visit visit = new Visit();

         Character array_ch[] = new Character[]{'-', '*', 'c', 'a', 'b'};
         BTree tree = new BTree(array_ch);
         //前序、中序和后序遍历
         tree.preOrder();
         visit.printLine();
         tree.inOrder();
         visit.printLine();
         tree.postOrder();
         visit.printLine();
         //获取节点数和树的深度
         System.out.println(tree.getNodeNum());
         System.out.println(tree.getDep());
     }

 }

测试输出