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

/**
 * 树状结构
 * 
 *
 * @param <T> 树中数据的类型
 */
public class Tree<T>
{
	private T data;
	
	/**
	 * 子树(节点)
	 */
	private List<Tree<T>> childs;
	
	/**
	 * 父节点
	 */
	private Tree<T> parent;
	private Long parentId;
	public Tree()
	{
		data = null;
		childs = new ArrayList<>();
		childs.clear();
	}
	
	public Tree(T data)
	{
		this.data = data;
		childs = new ArrayList<>();
		childs.clear();
	}
	
	/**
	 * 添加子树
	 * 
	 * @param tree 子树
	 */
	public void addNode(Tree<T> tree)
	{
		childs.add(tree);
		tree.setParent(this);
	}
	
	public Long getParentId()
	{
		return parentId;
	}

	public void setParentId(Long parentId)
	{
		this.parentId = parentId;
	}

	/**
	 * 置空树
	 */
	public void clearTree()
	{
		data = null;
		parent = null;
		childs.clear();
	}
	
	/**
	 * 求树的深度
	 * 
	 * @return 树的深度
	 */
	public int dept()
	{
		return dept(this);
	}
	
	/**
	 * 求树的深度
	 * 
	 * @param tree
	 * @return
	 */
	private int dept(Tree<T> tree)
	{
		if (tree.isEmpty())
		{
			return 0;
		}
		else if (tree.isLeaf())
		{
			return 1;
		}
		else
		{
			int n = childs.size();
			int[] a = new int[n];
			for (int i = 0; i < n; i++)
			{
				if (childs.get(i).isEmpty())
				{
					a[i] = 0 + 1;
				}
				else
				{
					a[i] = dept(childs.get(i)) + 1;
				}
			}
			Arrays.sort(a);
			return a[n - 1];
		}
	}
	
	/**
	 * 获取父树(节点)
	 * 
	 * @return
	 */
	public Tree<T> getParent()
	{
		return parent;
	}
	
	public void setParent(Tree<T> parent)
	{
		this.parent = parent;
	}
	
	public boolean hasParent()
	{
		return parent != null;
	}
	
	/**
	 * 返回第i个子树
	 * 
	 * @param i
	 * @return
	 */
	public Tree<T> getChild(int i)
	{
		return childs.get(i);
	}
	
	/**
	 * 求第一个孩子 结点
	 * 
	 * @return
	 */
	public Tree<T> getFirstChild()
	{
		return childs.get(0);
		
	}
	
	/**
	 * 求最后 一个孩子结点
	 * 
	 * @return
	 */
	public Tree<T> getLastChild()
	{
		return childs.get(childs.size() - 1);
	}
	
	/**
	 * 获取子树
	 * 
	 * @return
	 */
	public List<Tree<T>> getChilds()
	{
		return childs;
	}
	
	/**
	 * 判断是否为空树
	 * 
	 * @return 如果为空，返回true,否则返回false
	 */
	public boolean isEmpty()
	{
		if (childs.isEmpty() && data == null)
		{
			return true;
		}
		return false;
	}
	
	/**
	 * 判断是否为叶子结点
	 * 
	 * @return
	 */
	public boolean isLeaf()
	{
		if (childs.isEmpty())
		{
			return true;
		}
		return false;
	}

	public T getData()
	{
		return this.data;
	}
	 
	
	/**
	 * 求结点数
	 * 
	 * @return 结点的个数
	 */
	public int size()
	{
		return size(this);
	}
	
	/**
	 * 求结点数,有待完善
	 * 
	 * @param tree
	 * @return
	 */
	private int size(Tree<T> tree)
	{
		if (tree.isEmpty())
		{
			return 0;
		}
		else if (tree.isLeaf())
		{
			return 1;
		}
		else
		{
			int count = 1;
			int n = childs.size();
			for (int i = 0; i < n; i++)
			{
				if (!childs.get(i).isEmpty())
				{
					count += size(childs.get(i));
				}
			}
			return count;
		}
	}
	
	public static void main(String[] args)
	{
		Tree<String> tc = new Tree<String>("root");
		tc.addNode(new Tree("A"));
		tc.addNode(new Tree("B"));
		System.out.println("树的深度为：" + tc.dept());
		List<Tree<String>> list = tc.getChilds();
		System.out.println("子节点为：");
		for (Tree<String> node : list)
		{
			System.out.println(node);
		}
	}
	
	@Override
	public String toString()
	{
		return "Tree [data=" + data + "]";
	}
}

该Tree类有三个主要属性为父子节点引用和数据:

data用于保存数据

parent为父节点引用

childs为子节点引用