Question

我有一个数组列表，按以下顺序包含id： -

101 -> 103 -> 104 -> 105 -> 106 -> 107

以下是表结构： -

Parent | Child
null      101
101       103
101       104
103       105
103       106
104       107

现在我希望将数据视为 101 -> 103 -> 105-> 106 -> 104 -> 107，即处于适当的等级结构中。即，第一个父母，然后是其子女，然后是该孩子的孙子，然后是父母的第二个孩子。对层次结构的级别没有限制。

在Java中执行此操作的最佳方式是什么？

Answer 1

这是我想出的：

我创建了一个具有父子关系的Node对象。

然后我使用DFS遍历Node s。

这是一个完整的工作示例：

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

public class ListHierarchy {

    static class Node{
        private Node parent;
        private int value;
        private List<Node> children;

        public Node(int value, Node parent){
            this.value = value;
            this.parent = parent;
            this.children = new ArrayList<>();
            if(parent!=null && parent.children.contains(this)==false) {
                parent.children.add(this);
            }
        }

        public int value() {
            return value;
        }

        public Node parent() {
            return parent;
        }

        public List<Node> children() {
            return children;
        }

        @Override
        public String toString() {
            return String.valueOf(value);
        }

        @Override
        public boolean equals(Object obj) {
            if(!(obj instanceof Node)){
                return false;
            }
            Node that = (Node) obj;
            return this.value == that.value && this.parent == that.parent;
        }
    }

    public static void main(String[] args) {

        /*
         *Parent    Child
         * null      101
         * 101       103
         * 101       104
         * 103       105
         * 103       106
         * 104       107
         */

        List<Node> nodes = new ArrayList<>();
        Node n = new Node(101, null); // null parent means root node
        Node n1 = new Node(103, n);
        Node n2 = new Node(104, n);
        Node n3 = new Node(105, n1);
        Node n4 = new Node(106, n1);
        Node n5 = new Node(107, n2);

        nodes.add(n);
        nodes.add(n1);
        nodes.add(n2);
        nodes.add(n3);
        nodes.add(n4);
        nodes.add(n5);

        List<Node> ordered = new ArrayList<>();
        walk(n, ordered);

        System.out.println(ordered);
    }

    /**
     * Using DFS to walk through the Nodes
     * @param root - Root node from which to start DFS.
     * @param ordered - New Empty List to add nodes to.
     */
    public static void walk(Node root, List<Node> ordered) {
        ordered.add(root);
        for(Node child: root.children()) {
            walk(child, ordered);
        }
    }

}

以下是示例输出：

[101, 103, 105, 106, 104, 107]

希望这有帮助！

数组列表中的分层数据如何基于层次结构对其进行排序

1 个答案: