Question

我正在处理一个平面的对象列表，但它们在父子关系中相互关联。一个对象可以有任意数量的子节点，或者根本没有。我需要将这些对象显示为树，显示这些关系。应对树的每个级别进行排序（对象与Collections.sort()兼容）。

问题分为两个部分：

Java是否有一个很好的开箱即用的数据结构来保存这样的树，或者我是否需要从头开始编写一个？（这不是一项艰巨的任务，但是重新发明轮子没有任何意义）我知道Swing中的DefaultTreeModel ...但是这个应用程序在服务器端运行，并且使用Swing包将不受欢迎代码审查。
将平面列表加载到这样的数据结构中的最佳模式是什么？我的第一个想法是识别根级对象，然后使用递归方法遍历他们的子孙，孙子等等。但是，为了在树中的每个级别对对等体进行排序的要求...我是我在构建树时不确定是否更有意义地担心这个问题，或者在我解析树以供显示时担心它。

Answer 1

这是一个快速而又脏的Tree实现，它在所有级别上使用TreeSet（您可以提供比较器，或者使用自然顺序）：

public class Tree<T> {

    private final Node<T> rootElement;

    public void visitNodes(final NodeVisitor<T> visitor){
        doVisit(rootElement, visitor);
    }

    private static <T> boolean doVisit(final Node<T> node,
        final NodeVisitor<T> visitor){
        boolean result = visitor.visit(node);
        if(result){
            for(final Node<T> subNode : node.children){
                if(!doVisit(subNode, visitor)){
                    result = false;
                    break;
                }
            }
        }
        return result;
    }

    public interface NodeVisitor<T> {

        boolean visit(Node<T> node);
    }

    public Node<T> getRootElement(){
        return rootElement;
    }

    private static final class NodeComparator<T> implements Comparator<Node<T>>{

        private final Comparator<T> wrapped;

        @Override
        public int compare(final Node<T> o1, final Node<T> o2){
            return wrapped.compare(o1.value, o2.value);
        }

        public NodeComparator(final Comparator<T> wrappedComparator){
            this.wrapped = wrappedComparator;
        }

    }

    public static class Node<T> {

        private final SortedSet<Node<T>> children;

        private final Node<T> parent;

        private T value;

        private final Comparator<?> comparator;

        @SuppressWarnings("unchecked")
        Node(final T value, final Node<T> parent, final Comparator<?> comparator){
            this.value = value;
            this.parent = parent;
            this.comparator = comparator;
            children =
                new TreeSet<Node<T>>(new NodeComparator<T>((Comparator<T>) comparator));
        }

        public List<Node<T>> getChildren(){
            return new ArrayList<Node<T>>(children);
        }

        public Node<T> getParent(){
            return parent;
        }

        public T getValue(){
            return value;
        }

        public void setValue(final T value){
            this.value = value;
        }

        public Node<T> addChild(final T value){
            final Node<T> node = new Node<T>(value, this, comparator);
            return children.add(node) ? node : null;
        }

    }

    @SuppressWarnings("rawtypes")
    private static final Comparator NATURAL_ORDER = new Comparator(){

        @SuppressWarnings("unchecked")
        @Override
        public int compare(final Object o1, final Object o2){
            return ((Comparable) o1).compareTo(o2);
        }
    };

    private final Comparator<?> comparator;

    public Tree(){
        this(null, null);
    }

    public Tree(final Comparator<? super T> comparator){
        this(comparator, null);
    }

    public Tree(final Comparator<? super T> comparator, final T rootValue){
        this.comparator = comparator == null ? NATURAL_ORDER : comparator;
        this.rootElement = new Node<T>(rootValue, null, this.comparator);
    }

    public Tree(final T rootValue){
        this(null, rootValue);
    }

}

以下是一些针对它的示例代码：

final Tree<Integer> tree = new Tree<Integer>();
final Node<Integer> rootNode = tree.getRootElement();
rootNode.setValue(1);
final Node<Integer> childNode = rootNode.addChild(2);
final Node<Integer> newChildNode = rootNode.addChild(3);
newChildNode.addChild(4);
tree.visitNodes(new NodeVisitor<Integer>(){

    @Override
    public boolean visit(final Node<Integer> node){
        final StringBuilder sb = new StringBuilder();
        Node<Integer> curr = node;
        do{
            if(sb.length() > 0){
                sb.insert(0, " > ");
            }
            sb.insert(0, String.valueOf(curr.getValue()));
            curr = curr.getParent();
        } while(curr != null);
        System.out.println(sb);
        return true;
    }
});

输出：

1
  1> 2
  1> 3
  1> 3> 4

Answer 2

将平面列表加载到这样的数据结构中的最佳模式是什么？我的第一个想法是识别根级对象，然后使用递归方法遍历他们的子孙，孙子等。

如果我理解正确，你只有一个单独的列表，其元素之间没有任何具体关联，你可以以某种方式检测某个元素是否是另一个元素的孩子。

在这种情况下，您可以

对列表进行排序
（识别根节点，如果还不知道）
将根放入队列
从队列中取出第一个节点
从列表的第一个元素开始，检查每个元素是否是当前节点的子元素;如果是这样，将其添加到树的当前级别并将其放入队列
从第4步开始重复。

如果检测到父子关系成本很高，则可以通过为已经标识了树中位置的每个节点存储/归零的标志来提高性能，以便在遍历列表时跳过它们。或者，您可以将整个排序列表复制到链接列表中，以便从中删除已处理的元素。

Answer 3

Java中没有树结构，但有一些排序：TreeSet和TreeMap。请参阅一些提示java data-structure to simulate a data tree

Answer 4

你提出的方法是我会做的。

如何构建树实际上取决于您在初始列表中的信息。

如果每个节点都包含对其父节点及其子集合的引用，则不需要构建除根集合之外的任何内容。
如果每个节点只有对其父节点的引用，则需要构建一个树;但是您可以使用HashMap在数据上单次传递，将每个节点映射到其子节点的列表（您构建）。
如果节点甚至没有包含对父母的引用，那么你必须按照Péter的建议去做。

无论如何，我不会先打扰整个List。对大型列表进行排序比对具有相同总长度的大量小型列表进行排序要慢。（这是从排序为O（n log n）开始的。）

在每个级别具有多个子（已排序）的Java树结构

4 个答案: