我有一个数组列表,按以下顺序包含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中执行此操作的最佳方式是什么?
答案 0 :(得分:-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]
希望这有帮助!