解决方案 »

  1.   

    为什么需要这么复杂。。
    基本Tree结构不就是一个当前节点,一个父节点,一个子节点列表。。
    给个简单例子吧
    import java.util.*;public class Tree<T> {
    private Tree<T> parent;
    private T data;
    private List<Tree<T>> children;

    public Tree(T data) {
    this.data = data;
    this.children = new ArrayList<>();
    }

    public void addChild(Tree<T> child) {
    child.parent = this;
    this.children.add(child);
    }

    public T getData() {
    return data;
    }

    public void setData(T data) {
    this.data = data;
    }

    public Tree<T> getParent() {
    return this.parent;
    }

    public List<Tree<T>> getChildren() {
    return this.children;
    }

    public List<Tree<T>> getSiblings() {
    // 要求parent不为null,如有需要自行处理
    return this.parent.children;
    }

    public List<Tree<T>> getAncestors() {
    List<Tree<T>> ancestors = new ArrayList<>();
    Tree<T> tree = this.parent;

    while (tree != null) {
    ancestors.add(tree);
    tree = tree.parent;
    }

    return ancestors;
    }

    public List<Tree<T>> getDescendants() {
    List<Tree<T>> descendants = new ArrayList<>();

    for (Tree<T> child : this.children) {
    descendants.add(child);
    descendants.addAll(child.getDescendants());
    }

    return descendants;
    }
    }
      

  2.   

    楼主的节点的数据结构设计过于冗余,在你的基础上帮你写出来了
    import java.util.List;public class Test {
    public static void main(String[] args) {
    // Tree:
    // 获取当前节点的父节点
    // 获取当前节点的子节点
    // 获取当前节点的同级节点
    // 获取当前节点的祖先节点
    // 获取当前节点的子孙节点
    Tree t = new Tree();
    t.add(null, "祖父");
    t.add("祖父", "伯父");
    t.add("祖父", "父亲");
    t.add("祖父", "叔叔");
    t.add("伯父", "堂兄");
    t.add("父亲", "兄");
    t.add("父亲", "我");
    t.add("父亲", "弟");
    t.add("叔叔", "堂弟");
    t.add("我", "儿子");
    t.add("儿子", "孙子");//错误
    t.add("我", "女儿");
    t.add("女儿", "孙女");
    System.out.println(t.getParentNode("堂兄"));
    System.out.println();
    List<String> childNode = t.getChildNode("父亲");
    for (String string : childNode) {
    System.out.println(string);
    }
    System.out.println();
    List<String> peerNode = t.getPeerNode("父亲");
    for (String string : peerNode) {
    System.out.println(string);
    }

    // System.out.print("\nM的祖先节点为");
    // List<String> ancestorNode = t.getAncestorNode("M");
    // for (String string : ancestorNode) {
    // System.out.print(string);
    // }1
    System.out.println();
    List<String> ancestorNode = t.getAncestorNode("孙子");
    for (String string : ancestorNode) {
    System.out.println(string);
    }

    System.out.println();
    List<String> descendantrNode = t.getDescendantNode("我");
    for (String string : descendantrNode) {
    System.out.println(string);
    }
    }
    }import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;public class Tree {
    private Map<String, String> m1 = new HashMap<String, String>();// 保存所有节点
    private Map<String, List<String>> m2 = new HashMap<String, List<String>>();// 保存子节点
    private Map<String, List<String>> m3 = new HashMap<String, List<String>>();// 保存同级节点 // private Map<String, List<String>> m4 = new HashMap<String,
    // List<String>>();//保存祖先节点 /**
     * 添加节点
     * 
     * @param parentNode
     * @param childNode
     */
    public void add(String parentNode, String childNode) {
    m1.put(childNode, parentNode);
    // 添加子节点到m2 List<String> child = m2.get(parentNode);
    if (child == null) {
    child = new ArrayList<String>();
    m2.put(parentNode, child);
    }
    child.add(childNode);
    // 添加子节点到m3 /* 要想获得兄门 只需要知道父是谁 然后再看父的子们,下面的代码多余 */
    // List<String> peer = m3.get(childNode);
    // if (peer == null) {
    // peer = new ArrayList<String>();
    // m3.put(childNode, child);
    // }
    // peer.add(parentNode); //而且这句话根本没起到任何作用; } /**
     * 获取父节点
     * 
     * @param node
     * @return
     */
    public String getParentNode(String node) {
    return m1.get(node);
    } /**
     * 获取子节点
     * 
     * @param node
     * @return子节点集合
     */
    public List<String> getChildNode(String node) {
    return m2.get(node);
    } /**
     * 获取同级节点
     * 
     * @param node
     * @return同级节点
     */
    public List<String> getPeerNode(String node) {
    return m2.get(m1.get(node));// 给你改了
    } // /**
    // * 获取祖先节点
    // *
    // * @param node
    // * @return祖先节点
    // */
    public List<String> getAncestorNode(String node) {
    List<String> list = new ArrayList<String>();
    String tempNode = m1.get(node); while (tempNode != null) {
    list.add(tempNode);
    tempNode = m1.get(tempNode);
    } return list;
    } public List<String> getDescendantNode(String node) {
    List<String> list = new ArrayList<String>();
    Set<String> keySet = m2.keySet();
    List<String> tempNodes = m2.get(node); while (!tempNodes.isEmpty()) {
    if (keySet.contains(tempNodes.get(0))) {
    tempNodes.addAll(m2.get(tempNodes.get(0)));
    }
    list.add(tempNodes.remove(0));
    }
    return list;
    }
    }