java 实现二叉树01

二叉树java实现

代码

/**
 * 二叉树
 */
public class BinaryTree03 {

    private BiTNode bt;// 二叉树的根节点
    private int[] array; // 要储存的数据
    private int count = 0; // array[count]

    public BinaryTree03(){}

    public BinaryTree03(int[] array){
        this.array = array;
        bt = creatTree(array.length, bt);
    }

    /**
     * 这个方法就是用来创建传入的根节点和它左右孩子节点的,并且返回这个根节点
     * @param n 一共要创建节点的个数
     * @param bt 传入的根节点，就是要创建它的左右孩子节点的
     * @return 创建完后返回这个根节点
     */
    private BiTNode creatTree(int n,BiTNode bt){
        // 结束条件
        if(n <= 0){
            return null;
        }
        // 创建传入的这个节点
        bt = new BiTNode();
        // 添加节点数据
        bt.setData(array[count++]);
        n = n-1; // 需要创建的节点数量-1
        // 判断一下节点数量有多少
        // 如果是奇数左孩子树比右孩子树多创建一个节点
        if(n >= 1 && (n % 2 != 0)){
            bt.ichild = creatTree((n + 1) / 2, bt.ichild);
            bt.rchild = creatTree((n - 1) / 2, bt.rchild);
        }
        // 如果是偶数个则存入左右子树各一半
        if(n > 1 && (n % 2 == 0)){
            bt.ichild = creatTree(n / 2, bt.ichild);
            bt.rchild = creatTree(n / 2, bt.rchild);
        }
        return bt;
    }

    // 添加数组
    public void add(int[] array){
        this.array = array;
        add1();
    }

    private void add1(){
        bt = null;
        bt = creatTree(array.length, bt);
    }

    // 先序遍历
    public void preorderTraversal(){
        System.out.println("前序遍历：");
        preorderTraversal1(bt);
    }

    // 遍历
    private void preorderTraversal1(BiTNode bt){
        if(bt == null){
            return;
        }
        // 先输出数据
        System.out.print(bt.getData() + "  ");
        // 遍历左孩子节点
        preorderTraversal1(bt.ichild);
        // 再遍历右孩子节点
        preorderTraversal1(bt.rchild);
    }

    // 中序遍历
    public void inOrderTraverse(){
        System.out.println("\n" + "中序遍历：");
        inOrderTraverse1(bt);
    }
    // 遍历
    private void inOrderTraverse1(BiTNode bt){
        if (bt == null) {
            return;
        }
        // 先遍历左孩子节点
        inOrderTraverse1(bt.ichild);
        // 输出节点数据
        System.out.print(bt.getData() + "  ");
        // 再遍历右孩子节点
        inOrderTraverse1(bt.rchild);
    }
    //后序遍历
    public void postOrderTraverse(){
        System.out.println("\n" + "后序遍历：");
        postOrderTraverse1(bt);
    }

    // 遍历
    private void postOrderTraverse1(BiTNode bt){
        if (bt == null) {
            return;
        }
        // 先遍历左孩子节点
        postOrderTraverse1(bt.ichild);
        // 再遍历右孩子节点
        postOrderTraverse1(bt.rchild);
        // 输出节点数据
        System.out.print(bt.getData() + "  ");
    }
}

/**
 * 二叉树节点
 */
public class BiTNode {
    private int data; // 储存的数据
    public BiTNode ichild = null; // 左孩子
    public BiTNode rchild = null; // 右孩子、

    // 给数据赋值
    public void setData(int data){
        this.data = data;
    }
    // 获取值
    public int getData(){
        return data;
    }
}

public class Demo {
    public static void main(String[] args) {
        int[] array = new int[]{1,2,3,4,5,6,7,8,9};
        // 创建二叉树
        BinaryTree03 bt = new BinaryTree03(array);
        // 遍历
        bt.preorderTraversal();
        bt.inOrderTraverse();
        bt.postOrderTraverse();
    }
}

结果

前序遍历：
1  2  3  4  5  6  7  8  9  
中序遍历：
4  3  2  5  1  8  7  6  9  
后序遍历：
4  3  5  2  8  7  9  6  1