• 树的基本操作java版


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

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

    BTree.java

      1 package com.gxf.tree;
      2 
      3 /**
      4  * 定义数的属性和一些基本操作
      5  * @author Administrator
      6  *
      7  */
      8 public class BTree {
      9     /**
     10      * 树节点类
     11      * 这里用二叉链表,存储
     12      * @author Administrator
     13      *
     14      */
     15     class BTreeNode{
     16         private Object data;
     17         private BTreeNode lchild;
     18         private BTreeNode rchild;
     19         
     20         public BTreeNode(){
     21             lchild = null;
     22             rchild = null;
     23         }
     24         public void setData(Object data){
     25             this.data = data;
     26         }
     27         public void setLchild(BTreeNode lchild){
     28             this.lchild = lchild;
     29         }
     30         public void setRchild(BTreeNode rchild){
     31             this.rchild = rchild;
     32         }
     33         public Object getData(){
     34             return data;
     35         }
     36     }
     37     //下面是二叉树的一些属性
     38     private Object array[];//用数组保存所有树节点的数据
     39     private BTreeNode root;//根节点
     40     private Visit visit = new Visit();//java 不能将函数作为函数的参数,用一个类封装方法
     41     
     42     /**
     43      * 构造一棵树,指向根节点
     44      * @param array
     45      */
     46     public BTree(Object array[]){
     47         this.array = array;
     48         root = build(1);
     49     }
     50     
     51     /**
     52      * 根据成员变量array[]递归构造一棵树
     53      * 构造左子树、右子树
     54      * @return
     55      */
     56     public BTreeNode build(int i){
     57         int n = array.length;
     58         
     59         if(i <= n){//i在数组内,说明可以构造一个以array[i]为根节点的子树
     60             BTreeNode treeNode = new BTreeNode();
     61             treeNode.setData(array[i - 1]);//设置根节点
     62             treeNode.setLchild(build(2 * i));//构造左子树
     63             treeNode.setRchild(build(2 * i + 1));//构造右子树
     64             
     65             return treeNode;
     66         }else{
     67             return null;
     68         }
     69     }
     70     /**
     71      * 获取树的所有节点的个数
     72      */
     73     public int getNodeNum(){
     74         return getNodeNum(root);
     75     }
     76     /**
     77      * 计算所有节点的个数
     78      * 递归实现,左子树个数 + 右子树个数 + 1
     79      * @param root
     80      * @return
     81      */
     82     public int getNodeNum(BTreeNode root){
     83         if(null == root)
     84             return 0;
     85         else
     86         {
     87             return getNodeNum(root.lchild) + getNodeNum(root.rchild) + 1;
     88         }
     89         
     90     }
     91     /**
     92      * 获取树的高度
     93      * @return
     94      */
     95     public int getDep(){
     96         return getDep(root);
     97     }
     98     /**
     99      * 获取树的高度
    100      * 递归获取左右子树的高度,返回最高的那个
    101      * root为空,返回0,说明为空树,高度为0
    102      * 如果不为空,左子树和右子树高度较大值 +1为树的高度
    103      * @param root
    104      * @return
    105      */
    106     public int getDep(BTreeNode root){
    107         if(null == root)
    108             return 0;//空树返回0,高度为0,也是函数的出口
    109         else{
    110             int max = getDep(root.lchild);//获取左子树的高度
    111             if(max < getDep(root.rchild))
    112                 max = getDep(root.rchild);//获取右子树高度,并和左子树比较
    113             
    114             return max + 1;//因为不为空树,树的高度为左右子树高度的最大值 + 1
    115         }
    116         
    117     }
    118     /**
    119      * 前序遍历
    120      */
    121     public void preOrder(){
    122         preOrder(root);
    123     }
    124     /**
    125      * 前序遍历树,先遍历根节点,在遍历左节点,右节点
    126      * 
    127      * @param root
    128      */
    129     public void preOrder(BTreeNode root){
    130         if(null != root){
    131             visit.visit(root);
    132             preOrder(root.lchild);
    133             preOrder(root.rchild);
    134         }
    135     }
    136     /**
    137      * 中序遍历
    138      */
    139     public void inOrder(){
    140         inOrder(root);
    141     }
    142     /**
    143      * 中序遍历,县遍历左子树,根,最后遍历右子树
    144      * 递归实现
    145      * @param root
    146      */
    147     public void inOrder(BTreeNode root){
    148         if(null != root)
    149         {
    150             inOrder(root.lchild);
    151             visit.visit(root);
    152             inOrder(root.rchild);
    153         }
    154     }
    155     /**
    156      * 后序遍历
    157      */
    158     public void postOrder(){
    159         postOrder(root);
    160     }
    161     /**
    162      * 后序遍历,先遍历左子树,右子树和根节点
    163      * 这也用递归实现
    164      * @param root
    165      */
    166     public void postOrder(BTreeNode root){
    167         if(null != root){//这里可以看成递归的出口
    168             postOrder(root.lchild);
    169             postOrder(root.rchild);
    170             visit.visit(root);
    171         }
    172     }
    173 
    174 }

    Visit.java

     1 package com.gxf.tree;
     2 
     3 import com.gxf.tree.BTree.BTreeNode;
     4 
     5 
     6 public class Visit {
     7     public void visit(BTreeNode node){
     8         System.out.print(node.getData() + " ");
     9     }
    10     public void printLine(){
    11         System.out.println();
    12     }
    13 }

    Test.java

     1 package com.gxf.tree;
     2 
     3 public class Test {
     4 
     5     public static void main(String[] args) {
     6         Visit visit = new Visit();
     7         
     8         Character array_ch[] = new Character[]{'-', '*', 'c', 'a', 'b'};
     9         BTree tree = new BTree(array_ch);
    10         //前序、中序和后序遍历
    11         tree.preOrder();
    12         visit.printLine();
    13         tree.inOrder();
    14         visit.printLine();
    15         tree.postOrder();
    16         visit.printLine();
    17         //获取节点数和树的深度
    18         System.out.println(tree.getNodeNum());
    19         System.out.println(tree.getDep());
    20     }
    21     
    22 }

    测试输出

  • 相关阅读:
    第四百九十六天 how can I 坚持
    第四百九十四、五天 how can I 坚持
    第四百九十三天 how can I 坚持
    第四百九十二天 how can I 坚持
    第四百九十一天 how can I 坚持
    第四百九十天 how can I 坚持
    第四百八十九天 how can I 坚持
    第四百八十八天 how can I 坚持
    第四百八十七天 how can I 坚持
    第四百八十六天 how can I 坚持
  • 原文地址:https://www.cnblogs.com/luckygxf/p/4072245.html
Copyright © 2020-2023  润新知