Java 算法遍历整个树结构

答案：19+20+37+15=91

我在一次采访中提出了这个问题，我很想看到其他人的答案。因为，我对树遍历算法不太了解

我想出了这个。。。（我知道这不好；），只是在努力学习）

public Long objectSize（对象）{
List objectList=new ArrayList（）；
长和=sizeOf（对象）；
objectList=getRefs（对象）；
用于（对象：对象列表）{
总和+=对象大小（对象）；
}
回报金额；
}

---

我注意到我可能有一个循环，并通过stackoverflow错误运行，因为我没有检查我是否已经通过一个“节点”。然后我想我应该有另一个数据结构（比如处理键/值的hashmap）来处理临时列表以进行比较。

如果您处理的是真正的“树”结构，那么就不必担心周期

您已经有了基本的想法，但需要考虑递归调用的实际返回值。如果我们假设对象的总大小（

objectSize（）

）等于其子对象的大小加上其自身的大小（

sizeOf（）

），那么您只需确保将所有子树大小相加即可

这里有一种方法可以做到：

    public Long objectSize(Object object) {
    List<Object> objectList = new ArrayList<Object>();

    Long sum = sizeOf(object);
    objectList = getRefs(object);

    for(Object object : objectList){
           sum += objectSize(object);
    }

return sum;
}

public Long objectSize（对象）{
List objectList=getRefs（对象）；
长和=sizeOf（对象）；
用于（对象：对象列表）{
总和+=对象大小（对象）；
}
返回长值（总和）；
}

---

您缺少的是递归的

objectSize

调用返回了一个值，该值需要包括在返回值中（在本例中是通过加法）。我没有测试它，但这个简单的BFS搜索算法应该可以做到这一点

public Long objectSize(Object object) {
    List<Object> objectList = getRefs(object);
    long sum = sizeOf(object);

    for(Object object : objectList) {
         sum += objectSize(object);
    }

    return Long.valueOf(sum);
}

public Long objectSize（对象）{
长和=sizeOf（对象）；
队列q=新的LinkedList（）；
对于（对象o:getRefs（对象））{
q、 添加（o）；
}
while（q.peek（）！=null）{
对象子对象=q.poll（）；
sum+=sizeOf（子项）；
fore（对象o:getRefs（子对象））{
q、 添加（o）；
}
}
回报金额；
}

以下是我要做的：

我将构建一个包含有待探索的节点的堆栈，并在while循环中对其进行处理。由于我的Java技能在我脑海中的某个地方消失了，我不会给你一个实现，但我会解释这个过程：

输入：树T
输出：节点对象的总大小

通过将T.root（根节点）推入堆栈来初始化堆栈

将总大小初始化为0:size=0

当S不为空时：

让N成为S的头，我们pop S:N=pop（S）

如果存在N.leftChild和N.rightChild，则将它们推入S

更新大小：大小=大小+N.size

返回大小

---

你的问题不清楚。是

objectSize（对象）应该返回自身和所有子节点的大小？树中没有循环。树没有循环，但是如果结构的引用实际上没有形成DAG，代码可能仍会运行到循环中。我的意思是，对于每一对对象A和对象B，如果出于某种原因，引用是对称的，那么可以在getObjects（B）中有A，在getObjects（A）中有B。否则，我认为您的意思是
sum+=objectSize（object）在该循环中。如果我错了，请纠正我，但在您的示例中，函数应该返回
19+20+37+15=91
，我对吗？@G.Bach确实，您两个都对。实际上，我就是这样做的。我只是写得太快了。好极了！
    public Long objectSize(Object object) {
    List<Object> objectList = new ArrayList<Object>();

    Long sum = sizeOf(object);
    objectList = getRefs(object);

    for(Object object : objectList){
           sum += objectSize(object);
    }

return sum;
}

public Long objectSize(Object object) {
    List<Object> objectList = getRefs(object);
    long sum = sizeOf(object);

    for(Object object : objectList) {
         sum += objectSize(object);
    }

    return Long.valueOf(sum);
}

public Long objectSize(Object object) {
   long sum=sizeOf(object);

   Queue<Object> q= new LinkedList<Object>();
   for (Object o : getRefs(object)) {
      q.add(o);
   }
   while (q.peek() != null) {
      Object child= q.poll();
      sum+= sizeOf(child);
      fore (Object o : getRefs(child)) {
         q.add(o);
      }
   }
   return sum;   
}