java实现树

实现一颗树，采用数组的存储方式，将树中的节点用Node类表示，方便与操作。
首先，整棵树的数组结构如下表所示，根节点的无父节点，用“-1”表示。

index	Data	parent
0	A	-1
1	B	0
2	C	0
3	D	0
4	E	1
5	F	1
6	G	5

其次，定义一个节点Node类，用来存储每个节点的内容

[java] view
plaincopy

package my.tree;  

  

public class Node<T> {  

    private T data;  

    private int parent;  

      

    public Node(){  

    }  

      

    public Node(T data){  

        this.data = data;  

    }  

      

    public Node(T data,int parent){  

        this.data = data;  

        this.parent = parent;  

    }  

      

    public void setData(T data){  

        this.data = data;  

    }  

      

    public T getData(){  

        return this.data;  

    }  

      

    public void setParent(int parent){  

        this.parent = parent;  

    }  

      

    public int getParent(){  

        return this.parent;  

    }  

}  

开始实现树，提供基本的插入节点、获取所有节点、获取树的深度操作（着重）这些将数组大小设置为2，主要是考虑数组能否自动扩容;

[java] view
plaincopy

package my.tree;  

  

import java.util.ArrayList;  

import java.util.Arrays;  

import java.util.List;  

  

public class MyTree<T> {  

    private final int DEFAULT_SIZE = 2;  

    private int size;  

    private int count;  

    private Object[] nodes;  

  

    public MyTree() {  

        this.size = this.DEFAULT_SIZE;  

        this.nodes = new Object[this.size];  

        this.count = 0;  

    }  

  

    public MyTree(Node<T> root) {  

        this();  

        this.count = 1;  

        this.nodes[0] = root;  

    }  

  

    public MyTree(Node<T> root, int size) {  

        this.size = size;  

        this.nodes = new Object[this.size];  

        this.count = 1;  

        this.nodes[0] = root;  

    }  

  

    //添加一个节点  

    public void add(Node<T> node) {  

        for (int i = 0; i < this.size; i++) {  

            if (this.nodes[i] == null) {  

                nodes[i] = node;  

                break;  

            }  

        }  

        this.count++;  

    }  

  

    public void check(){  

        if(this.count >= this.size){  

            this.enlarge();  

        }  

    }  

    //添加一个节点，并指明父节点  

    public void add(Node<T> node, Node<T> parent) {  

        this.check();  

        node.setParent(this.position(parent));  

        this.add(node);  

    }  

  

    //获取节点在数组的存储位置  

    public int position(Node<T> node) {  

        for (int i = 0; i < this.size; i++) {  

            if (nodes[i] == node) {  

                return i;  

            }  

        }  

        return -1;  

    }  

      

    //获取整棵树有多少节点  

    public int getSize(){  

        return this.count;  

    }  

      

    //获取根节点  

    @SuppressWarnings("unchecked")  

    public Node<T> getRoot(){  

        return (Node<T>) this.nodes[0];  

    }  

      

    //获取所以节点，以List形式返回  

    @SuppressWarnings("unchecked")  

    public List<Node<T>> getAllNodes(){  

        List<Node<T>> list = new ArrayList<Node<T>>();  

        for(int i=0;i<this.size;i++){  

            if(this.nodes[i] != null){  

                list.add((Node<T>)nodes[i]);  

            }  

        }  

        return list;  

    }  

      

    //获取树的深度，只有根节点时为1  

    @SuppressWarnings("unchecked")  

    public int getDepth(){  

          

        int max = 1;  

        if(this.nodes[0] == null){  

            return 0;  

        }  

          

        for(int i=0;i<this.count;i++){  

            int deep = 1;  

            int location = ((Node<T>)(this.nodes[i])).getParent();  

            while(location != -1 && this.nodes[location] != null){  

                location = ((Node<T>)(this.nodes[location])).getParent();  

                deep++;  

            }  

            if(max < deep){  

                max = deep;  

            }  

        }  

        return max;  

    }  

      

    public void enlarge(){  

        this.size = this.size + this.DEFAULT_SIZE;  

        Object[] newNodes = new Object[this.size];  

        newNodes = Arrays.copyOf(nodes, this.size);  

        Arrays.fill(nodes, null);  

        this.nodes = newNodes;  

        System.out.println("enlarge");  

    }  

}  

最后，使用MyTreeClient来测试下，基本功能是否都已经实现;

[java] view
plaincopy

package my.tree;  

  

public class MyTreeClient {  

    public static void main(String[] args){  

        Node<String> root = new Node<String>("A",-1);  

        MyTree<String> tree = new MyTree<String>(root);  

        Node<String> b = new Node<String>("B");  

        Node<String> c = new Node<String>("C");  

        Node<String> d = new Node<String>("D");  

        Node<String> e = new Node<String>("E");  

        Node<String> f = new Node<String>("F");  

        Node<String> g = new Node<String>("G");  

        tree.add(b,root);  

        tree.add(c,root);  

        tree.add(d,root);  

          

        tree.add(e,b);  

        tree.add(f,b);  

        tree.add(g,f);  

          

          

        System.out.println(tree.getSize());  

        System.out.println(tree.getRoot().getData());  

        System.out.println(tree.getAllNodes());  

        System.out.println(tree.getDepth());  

        tree.add(new Node<String>("H"),g);  

        System.out.println(tree.getDepth());  

        tree.enlarge();  

    }