（java）二叉树，要命的作业。。。。前人来踩坑

编写程序，用插入左、右子树递归的方法建立一棵二叉树，其含有的结点数至少10个，接着分别使用先序遍历、中序遍历、后序遍历对二叉树进行遍历输出，然后试着删除二叉树的某个左子树或右子树，最后将二叉树按缩进结构打印出来，


import java.util.LinkedList;
import java.util.Queue;

/**
 * 二叉树
 * @param <T>
 */
class Tree<T> {
    public class Entry { //树的节点类
        T data;
        Entry left;
        Entry right;

        public Entry(T data) {
            this.data = data;
            this.left = null;
            this.right = null;
        }
    }

    private Entry root = null;  //根节点

    /**
     * 设置父节点
     * @param data
     */
    public void setRoot(T data) {
        this.root = new Entry(data);
    }

    /**
     * 获取父节点
     * @return
     */
    public Entry getRoot() {
        return root;
    }

    /**
     * 添加节点
     * @param value 要添加的节点的值
     * @param index 添加在父节点的左(0)或右（1）
     * @param father_data 要添加的节点的父节点
     */
    public void add(T value,int index,T father_data) {
        if(root == null) {
            System.out.println("请先设置根节点！");
            return;
        }
        Entry dad = find_father_node(root,father_data);
        if(dad == null) {
            System.out.println("不存在该节点！！！");
            return;
        }
        if(index == 0) {
            if(dad.left == null) {
                dad.left = new Entry(value);
            }else {
                System.out.println("此节点已被占用");
            }
        }else {
            if(dad.right == null) {
                dad.right = new Entry(value);
            }else {
                System.out.println("此节点已被占用");
            }
        }
    }

    /**
     * 寻找当前要添加节点的父节点
     * @param root
     * @param father_data
     * @return
     */
    private Entry find_father_node(Entry root,T father_data) {
        Entry ptr;
        if(root == null) {
            return null;
        }
        if(root.data == father_data) {
            return root;
        }else {
            if((ptr = find_father_node(root.left,father_data)) != null) {
                return ptr;
            }else if((ptr = find_father_node(root.right,father_data)) != null) {
                return ptr;
            }else {
                return null;
            }
        }
    }

    /**
    * 删除在当前二叉树的parent节点中的右子树
     * @param index 删除在父节点的左(0)或右（1）
     * @param father_data 要删除的节点的父节点
     */
    public boolean deleteTree(int index, T father_data){
        if(root == null) {
            System.out.println("请先设置根节点！");
            return false;
        }
        Entry dad = find_father_node(root,father_data);
        if(dad == null) {
            System.out.println("不存在该节点！！！");
            return false;
        }
        if(index == 0) {
            if(dad.left == null) {
                return true;
            }else {
                dad.left = null;
            }
        }else {
            if(dad.right == null) {
                return true;
            }else {
                dad.right = null;
            }
        }
        return true;
    }


    /**
     * 先序遍历树
     * @param node
     */
    public void preorder(Entry node) {
        if(node != null) {
            show(node);
            preorder(node.left);
            preorder(node.right);
        }

    }


    /**
     * 中序遍历树
     * @param node
     */
    public void inorder(Entry node) {
        if(node != null) {
            inorder(node.left);
            show(node);
            inorder(node.right);
        }
    }
    /**
     * 后序遍历树
     * @param node
     */
    public void postorder(Entry node) {
        if(node != null) {
            postorder(node.left);
            postorder(node.right);
            show(node);
        }
    }
    /**
     * 层次遍历二叉树
     */
    public void levelorder() {
        //创建队列，存储二叉树节点
        Queue<Entry> queue = new LinkedList<>();
        //把根节点存到队尾
        queue.add(getRoot());
        //当队列不是空的时候，将队列头移除，将其儿子节点加入队列
        while(!queue.isEmpty()){
            Entry cur = queue.remove();
            System.out.println(cur.data);
          if(cur.left!=null)
              queue.add(cur.left);
          if(cur.right!=null)
              queue.add(cur.right);


    }}


    /**
     * 打印节点数据
     * @param node
     */
    private void show(Entry node) {
        System.out.print(node.data+"\t");
    }
    /**缩进打印*/
    public void printBinaryTree(Entry node, int i) {
        if (node == null) return;
        else {
            for (int j = 0; j < i; j++) {
                System.out.print("-");
            }
            System.out.println(node.data);
            printBinaryTree(node.left, i+=4);
            i-=4;
            printBinaryTree(node.right, i+=4);
            i-=4;
        }
    }


    /**
     * 获得树的深度
     * @param node
     * @return
     */
    public int getLength(Entry node) {
        int depleft,depright;
        if(node == null) {
            return 0;
        }else {
            depleft = getLength(node.left);
            depright = getLength(node.right);
            if(depleft > depright) {
                return depleft+1;
            }else {
                return depright+1;
            }
        }
    }
}

 

另一个包的测试数据：

package Nodes;

public class Main {
    public static void main(String[] args) {
        Tree<String> tree = new Tree<>();
        tree.setRoot("A");
        tree.add("B",0,"A");
        tree.add("C",1,"A");
        tree.add("D",1,"B");
        tree.add("E",1,"C");
//        tree.add("F",1,"C");
        tree.add("G",0,"D");
        tree.add("H",1,"D");
        tree.add("I",1,"E");
//        tree.add("K",0,"F");
        System.out.println("先序遍历");
        tree.preorder(tree.getRoot());
        System.out.println("\n");
        System.out.println("中序遍历");
        tree.inorder(tree.getRoot());
        System.out.println("\n");
        System.out.println("后续遍历序遍历");
        tree.postorder(tree.getRoot());
        System.out.println("\n树的深度"+tree.getLength(tree.getRoot()));

        System.out.println("\n");
        System.out.println("层次遍历");
        tree.levelorder();
        System.out.println("缩进打印，i为8个 - ");
       tree.printBinaryTree(tree.getRoot(),8);



        System.out.println("删除后");
        System.out.println("删除D父节点下的，左1子树，");
        tree.deleteTree(1,"D");
        tree.printBinaryTree(tree.getRoot(),8);

    }

}

//测试结果。

//要命的数据结构，脑瓜子快不够用了