树&二叉树

import java.util.ArrayList;
import java.util.List;

public class TreeParent<E> 
{
    public static class Node<T>
    {
        T data;
        int parent; //记录父节点
        
        public Node(){}
        public Node(T data)
        {
            this.data = data;        
        }
        public Node(T data,int parent)
        {
            this.data = data;
            this.parent = parent;
        }
        
        public String toString()
        {
            return "TreeParent--Node[data="+data+", parent="+parent+"]";
        }
    }
    private final int DEFAULT_TREE_SIZE = 100;
    private int treeSize = 0;  //存放节点的数组的容量(树的容量)
    private int nodeNums;  //当前节点数量
    
    private Node[] nodes; //记录所有的节点
    public TreeParent(E data) //以指定根节点创建树
    {
        treeSize = DEFAULT_TREE_SIZE;
        nodes = new Node[treeSize];
        nodes[0] = new Node<E>(data,-1);
        nodeNums++; //当前节点数量增加
    }
    public TreeParent(E data,int treeSize)//指定树的容量
    {
        this.treeSize = treeSize;
        nodes = new Node[treeSize];
        nodes[0] = new Node<E>(data,-1);
        nodeNums++; //当前节点数量增加
    }
    public void addNode(E data,Node parent) 
    //为指定节点添加子节点,注意传入的是Node,并且Node是static的
    {
        //先要判断一下树是否已满,数组中不存在为null的元素
        
        for (int i = 0 ; i < treeSize ; i++)
        {
            if (nodes[i] == null)//找到数组中第一个为null的元素，该元素保存新节点
            {
                //创建新节点，并用指定的数组元素保存它
                nodes[i] = new Node(data , pos(parent));//请注意这里实例化静态内部类
                nodeNums++;
                return;
            }
        }
        throw new RuntimeException("该树已满，无法添加新节点");
    }
    private int pos(Node parent) //返回指定节点的索引
    {
        for (int i = 0 ; i < treeSize ; i++)
        {
            //找到指定节点
            if (nodes[i] == parent)
            {
                return i;
            }
        }
        return -1;
    }
    public boolean empty()//判断树是否为空。
    {
        return nodes[0] == null;//根节点是否为null
    }
    public Node<E> root()//返回根节点
    {
        return nodes[0];//返回根节点
    }
    public Node<E> parent(Node node)//返回指定节点（非根节点）的父节点
    {
        //每个节点的parent记录了其父节点的位置
        return nodes[node.parent];
    }
    public List<Node<E>> children(Node parent)//返回指定节点（非叶子节点）的所有子节点
    {
        List<Node<E>> list = new ArrayList<Node<E>>();
        for (int i = 0 ; i < treeSize  ; i++)
        {
            //如果当前节点的父节点的位置等于parent节点的位置
            if (nodes[i] != null &&
                nodes[i].parent == pos(parent))
            {
                list.add(nodes[i]);
            }
        }
        return list;
    }
    public int deep()//返回该树的深度--从节点数组中的每一个节点开始向上不断找父节点,不断加1
    {
        
        int max = 0;//用于记录节点的最大深度
        for(int i = 0 ; i < treeSize && nodes[i] != null; i++)
        {
            int def = 1; //初始化本节点的深度
            int m = nodes[i].parent;//m记录当前节点的父节点的位置
            while(m != -1 && nodes[m] != null)//如果其父节点存在
            {
                m = nodes[m].parent;//向上继续搜索父节点
                def++;
            }
            if(max < def)
            {
                max = def;
            }
        }
        return max; //返回最大深度
    }
    
/*    public static void main(String[] args) {
        TreeParent<String> tp = new TreeParent<String>("root");
        TreeParent.Node root = tp.root();
        System.out.println(root);
        tp.addNode("节点1" , root);
        System.out.println("此树的深度:" + tp.deep());
        tp.addNode("节点2" , root);
        //获取根节点的所有子节点
        List<TreeParent.Node<String>> nodes = tp.children(root);
        System.out.println("根节点的第一个子节点：" + nodes.get(0));
        //为根节点的第一个子节点新增一个子节点
        tp.addNode("节点3" , nodes.get(0));
        System.out.println("此树的深度:" + tp.deep());
    }*/
}