对于树结构如下
public class Node implements Comparable<Node> {
private List<Node> nodes=new ArrayList<Node>();
private String name="";
private List<String> leaves=new ArrayList<String>();
private Node parent=null;
public List<Node> getNodes() {
return nodes;
}
public void setNodes(List<Node> nodes) {
this.nodes = nodes;
}
public List<String> getLeaves() {
return leaves;
}
public void setLeaves(List<String> leaves) {
this.leaves = leaves;
}
@Override
public int compareTo(Node o) {
return this.getName().compareTo(o.getName());
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Node getParent() {
return parent;
}
public void setParent(Node parent) {
this.parent = parent;
}
public int getDepth() {
int depth = 0;
Node parent = this.getParent();
while (parent != null) {
depth++;
parent = parent.getParent();
}
return depth;
}
}
从一个节点,我希望有一个方法返回所有不同的直接和间接叶子(在上面的例子中,字符串leaves
将是叶子),对于该节点按排序顺序。
以上是高度拆解数据结构,便于测试和演示。我尝试了以下3种方法,
方法A. 当深度大~20时非常慢,因为最深的叶子被遍历了几次,每个祖先一次,因此相同的路径被遍历多次。
public List<String> getLeavesDeep1() {
Set<String> leaves = new TreeSet<String>();
leaves.addAll(getLeaves());
for (Node node : getNodes()) {
leaves.addAll(node.getLeavesDeep1());
}
return new ArrayList<String>(leaves);
}
平均:12694毫秒/没有排序/不同&gt;平均:471毫秒
方法B. 比A快一点,因为节点的数量相对非常少,因此使用方法A但是对于节点,然后对于每个节点,只获得直接离开。
private List<Node> getNodesDeep2() {
Set<Node> nodes = new TreeSet<Node>();
nodes.addAll(getNodes());
for (Node node : getNodes()) {
nodes.addAll(node.getNodesDeep2());
}
return new ArrayList<Node>(nodes);
}
public List<String> getLeavesDeep2() {
Set<String> leaves = new TreeSet<String>();
leaves.addAll(getLeaves());
for (Node node : getNodesDeep2()) {
leaves.addAll(node.getLeaves());
}
return new ArrayList<String>(leaves);
}
平均值:4355毫秒/没有排序/不同&gt;平均:2406毫秒
方法C. 避免使用TreeSet,使用ArrayList和sort&amp;在返回之前过滤(不是排序/区分的最佳方式)
private List<Node> getNodesDeep3() {
List<Node> nodes = new ArrayList<Node>();
nodes.addAll(getNodes());
for (Node node : getNodes()) {
nodes.addAll(node.getNodesDeep3());
}
return new ArrayList<Node>(new TreeSet<Node>(nodes));
}
public List<String> getLeavesDeep3() {
List<String> leaves = new ArrayList<String>();
leaves.addAll(getLeaves());
for (Node node : getNodesDeep3()) {
leaves.addAll(node.getLeaves());
}
return new ArrayList<String>(new TreeSet<String>(leaves));
}
平均值:4400
寻找更快的东西,我知道可以使用某些树遍历,但如果存在,我希望更简单。 P.S。这些不是用于搜索的用例。在我的真实班级中,时间比上述情况高出约3倍,因为结构更加复杂,叶子不是简单的字符串,而是POJO
以下是我用来获得时间的测试
private static final int NODES = 5;
private static final int LEAVES = 25;
private static final int DEPTH = 8;
public void addChildren(Node parent) {
List<Node> nodes = new ArrayList<Node>();
List<String> leaves = new ArrayList<String>();
for (int i = 0; i < LEAVES; i++) {
leaves.add(String.format("%s_leaf_%s", parent.getName(), i));
}
for (int i = 0; i < NODES; i++) {
Node child = new Node();
child.setParent(parent);
child.setName(String.format("%s_%s", parent.getName(), i));
nodes.add(child);
if (child.getDepth() < DEPTH) {
addChildren(child);
}
}
parent.setNodes(nodes);
parent.setLeaves(leaves);
}
@Test
public void testCase() {
long start, tot=0;
long t = 0;
List<String> leaves;
Node target = new Node();
target.setName("Root");
addChildren(target);
for (int i = 0; i < 10; i++) {
start = System.currentTimeMillis();
leaves = target.getLeavesDeep5();
t = System.currentTimeMillis() - start;
tot += t;
System.out.println(leaves.size() + " " + t);
}
System.out.println("Avg: " + (tot / 10));
}
任何语言的答案都是可以接受的,包括伪代码,只要它没有将解决方案与该语言紧密联系起来(异常:纯Java代码被禁止从第二个句子)
答案 0 :(得分:1)
我运行了测试,它给了我以下结果(我使用的是你的版本3,一个稍微修改过的版本3和一个新版本)
2441400 8038
...
2441400 7890
Avg: 7872
2441400 4850
...
2441400 3990
Avg: 4165
2441400 980
...
2441400 710
Avg: 786
我先改变了
return new ArrayList<String>(new TreeSet<String>(leaves));
到
Collections.sort(leaves);
return leaves;
请参阅Is it faster to add to a collection then sort it, or add to a sorted collection?
这使执行时间减少了近50%。 注意: TreeSet将删除重复项,排序不会。
然后我写了一个新的Iterator方法,将你的两个方法合二为一,并一起消除递归。我还摆脱了ArrayLists,以避免我们不需要的调整大小和复制,因为我们只是迭代并且永远不会通过索引访问。
编辑:使用ArrayList存储树叶的时间从800毫秒增加到大约1400毫秒。
public List<String> getLeavesDeepX()
{
final Deque<Node> nodes = new LinkedList<Node>();
final Collection<String> leaves = new LinkedList<String>();
//final Collection<String> leaves = new LinkedHashSet<String>(); -- use for removing dupes
nodes.add(this);
do
{
final Node current = nodes.pop();
leaves.addAll(current.getLeaves());
nodes.addAll(current.getTreeNodes());
}
while(nodes.isEmpty() == false);
final ArrayList<String> result = new ArrayList<String>(leaves);
Collections.sort(result);
return result;
}
我将所有结果放入不同的列表中,并在最后对比。
System.out.println(Arrays.equals(leaves1.toArray(), leaves2.toArray()));
System.out.println(Arrays.equals(leaves1.toArray(), leaves3.toArray()));
System.out.println(Arrays.equals(leaves2.toArray(), leaves3.toArray()));
输出:
true
true
true
所以至少在我的系统上它的速度提高了10倍。
Edit2 :在第3种情况下跳过排序会使其达到140毫秒。所以600ms用于比较和排序。需要在那里进行任何进一步的重大改进。
Edit3 :消除递归还有一个好处,即树的深度对性能的影响较小。将TestTree更改为2/2/20(N / L / D)会产生大约相同数量的叶子(2m),但是在递归(> 70k)时表现更差,但是没有更慢(从1200到2500)。 / p>