数据结构——树(Java语言描述)

@SuppressWarnings(value = "all")
public class Tree<T> {

    //Tree构造器,构造一个TreeRoot
    public Tree() {
        treeRoot = new Node();
    }
    // 基于数组的树

    //孩子数组默认初始大小
    static int DEFAULT_SIZE = 10;

    //树根,Tree对象负责维护该对象。
    private Node treeRoot;

    //指向当前叶子的指针
    private Node cur;

    //节点内部类,树结构的基本组成单位。
    static class Node<T> {

        //孩子数组中元素的个数
        private int size = 0;

        //父节点指针
        private Node<T> paraent;

        private Node<T>[] children = new Node[DEFAULT_SIZE];

        //叶子数据域
        private T t;

        //叶子名称
        private String name;

        //Node对外提供两个构造方法.一个无参构造用于构造树根元素,另外一个负责构造叶子节点元素。
        public Node() {
            this.name = "树根";
        }

        public Node(T t, String name) {
            this.t = t;
            this.name = name;
        }
    }

}

public void add(Node<T> node){
//调用find()方法找到当前操作节点,然后通过addNode()方法添加到该节点的孩子数组中
        Node parent = find();
        addNode(parent, node);
}

public Node<T> find(){
        //使当前节点成为树根节点
        Node cur = treeRoot;
        Scanner scanner = new Scanner(System.in);
        
        //标识用户操作的字符串
        String flag = null;
        
        //标识节点在数组中的下标变量
        int index = 0;

        //用于接收当前节点的孩子数组
        Node[] nodes = null;
        
        //需要在循环条件下对节点进行挑选操作
        while(true){        
            System.out.println("当前父节点:"+cur.name);
            System.out.println("当前节点添加或者是否继续遍历子节点?");//
            //(ps:按1遍历当前节点的孩子数组,按2在当前节点插入叶子节点。就相当在当前文件夹添加文件，还是进入子文件夹中)
            flag = scanner.nextLine();
            //如果选择1，则表示遍历当前节点的孩子数组。
            if(flag.equals("1")){
                //通过finjNodes()方法得到当前节点的孩子节点数组
                nodes = findNodes(cur);
                //如果数组中的元素个数为0,则结束本次操作。
                if(cur.size==0){
                        System.out.println("无子节点,本次插入操作结束!");
                        return null;
                }
                //如果不为零则输出所有不为null的孩子节点
                for (int i = 0; i < nodes.length; i++) {
                    if(nodes[i]!=null)
                        System.out.print(nodes[i].name+"("+i+")"+"         ");
                }
                //选择一个节点进行操作
                System.out.println("请选中一个节点(ps:选择方式根据括号下标)");
                //操作使用while循环,防止用户输入字符不是数字而跳出try语句块。
                while(true){
                    try {
                        index = Integer.valueOf(scanner.nextLine());
                        cur = nodes[index];
                        if(cur==null){
                            System.out.println("节点不存在,请重新输入");
                            continue;
                        }
                        break;
                    } catch (Exception e) {
                        System.out.println("输入下标格式不正确,请重新输入!");
                    }
                }
            }
            //不为1,则返回当前节点。
            else{
                /**try {
                    
                } finally {
                    //System.out.println("关闭流");
                    //scanner.close();这里关闭流了,然后下次调用该方法反而会引发异常??
                }
                */
                System.out.println();
                return cur;
            }
        }
    }

//该方法传入一个父节点与一个子节点指针
public void addNode(Node<T> parent, Node<T> node) {
        //如果父节点不为null    
        if(parent!=null){
            //得到父节点所有孩子的数量
            int size = parent.size;
            //在增加元素之前调用enSureSize()方法,进行是否需要扩容检查.
            enSureSize(size+1, parent);
            //父节点增加一个元素
            parent.children[size] = node;
            parent.size++;
        }
}

public void enSureSize(int minCapcity, Node parent) {
        //minCapcity为父节点当前所有孩子的数量,从默认大小和孩子数量之间选择一个较大数
        minCapcity = Math.max(DEFAULT_SIZE, minCapcity);
        //如果孩子数量超过了当前数组的长度,则调用grow()方法
        if (minCapcity - parent.children.length > 0)
            grow(minCapcity, parent);
    }

public void grow(int minCapcity, Node<T> parent) {
        //限制数组的最大长度
        if (minCapcity > Integer.MAX_VALUE - 8) {
            System.out.print("数组长度超过最大长度限制");
            return;
        }
        Node[] arrys = parent.children;
        int oldLength = arrys.length, newLength;
        newLength = oldLength + (int) (0.5 * oldLength);// 0.5倍扩容
        //如果数量大于新的数组长度,则让孩子数量为新的数组长度
        if (minCapcity > newLength)
            newLength = minCapcity;
        //Arrays工具类提供的一个native方法,实现数组的高效拷贝。
        parent.children = Arrays.copyOf(arrys, newLength);
    }

public static void main(String[] args) {
        //实例化一个类型为String的Tree    
        Tree<String> tree = new Tree<String>();
        for (int i = 0; i < 10; i++) {
            //生成十个数据域为(0-10)随机数，名称为"Node"+i的叶子
            tree.add(new Node(""+(int)(Math.random()*10), "Node"+i));
        }
    }