Java 查找父级和其他父级的数组树以及到根的短路径

我想找到从一个孩子到他的父母，到祖父母，最后到根的最短路线

例如，

输入0 0 1 2

，表示：

input[1] parent is 0 (route = 1)
input[2] also has parent 0 (route = 1) 
input[3] has parent 1 which has parent 0 (route = 2)
input[4] has parent 2 which has parent 0 (route = 2)

迄今为止的代码：

创建的数组名为

targetNodes

，其中包含

0 1 2

System.out.print( "0 " );

for ( int x = 1; x < arrayLength; x++ )
{

  int depth = 1;
  int parent = 0;

  while ( targetNodes[x] != 0 ) 
  {
      depth++;
      targetNodes[x] = targetNodes[ targetNodes[x] ] ;
  }   

  // output shortest path from node to root for every node
  System.out.print( depth + " " );

}

System.out.print("\n");

系统输出打印（“0”）；
对于（int x=1；x

我的示例使用输入：

0 0 0 1 2

打印：

0 1 2

， 但对于输入：

0 0 0 1 2 1 4

当正确的输出为：

0 1 2 2 3

---

我不确定我做错了什么，我想这是逻辑，其实很简单。最困难的部分是转换单元测试的数据，以便有效地键入它们

package so7455242;

import static org.junit.Assert.*;

import org.junit.Test;

import com.google.common.primitives.Ints;

public class DistanceFinder {

  private static int[] findPathLengths(int[] parent) {
    int[] distances = new int[parent.length];
    for (int i = 0; i < parent.length; i++) {
      int distance = 0;
      for (int node = i; node != 0; node = parent[node]) {
        distance++;
      }
      distances[i] = distance;
    }
    return distances;
  }

  private static int[] toIntArray(String s) {
    String[] words = s.split(" ");
    int[] ints = new int[words.length];
    for (int i = 0; i < ints.length; i++) {
      ints[i] = Integer.parseInt(words[i]);
    }
    return ints;
  }

  private static void testcase(String expected, String input) {
    int[] nodeDefinitions = toIntArray(input);
    int[] pathLengths = findPathLengths(nodeDefinitions);
    String actual = Ints.join(" ", pathLengths);
    assertEquals(expected, actual);
  }

  @Test
  public void test() {
    testcase("0 1 1 2 2", "0 0 0 1 2");
    testcase("0 1 2 3 2 3", "0 0 1 2 1 4");
  }

}

包so7455242；
导入静态org.junit.Assert.*；
导入org.junit.Test；
导入com.google.common.primitives.Ints；
公共类测距仪{
私有静态int[]findPathLength（int[]父级）{
int[]距离=新的int[parent.length]；
for（int i=0；i

我不太清楚您的代码是做什么的，但您应该明确地将逻辑与输出分开。创建一个方法

int[]findPathLength（int[]nodeDefinitions）

。然后您可以轻松地为这个方法编写单元测试。我假设

targetNodes

包含节点之间的关系。因为找到最短距离不会以任何方式修改这些关系，所以您的代码也不应该这样做。不分配给

targetNodes[x]

。