在Java中迭代数组（从2D数组中推导出1D）

我正在尝试编写一段Java代码，它可以从2D整数数组推断出一维整数数组。我的2D阵列看起来像这样：

Node1  Node2   Path
 6      8      501
 2      6      500 
 8      10     505 
 2      4      502

我的任务如下。我想找到从第一列（节点1）的元素到第二列（节点2）的元素的“路径”。我的意思是这样的：

从“2”到“8”的路径将按该顺序为

500 501

。从“2”到“4”的路径是

502

（不是

500

，因为它终止于“6”）

我一直试图通过使用SimpleFor循环进行迭代来实现这一点，但一直在努力。有人能告诉我怎么解决这个问题吗

我试图编写的代码片段如下：

            PathSequence:
            for(int i = 0; i < PathGraphRow; i++){
                if(PathGraph[i][0] == source){
                    if(i==0)
                    {
                        nextNode = PathGraph[i][1];
                        resultantPaths[counter] = PathGraph[i][2];
                        prev = lightPathGraph[i][2];
                        if(nextNode == dest){
                            break PathSequence;
                        }
                        counter++;
                    }else if(i > 0 && prev != PathGraph[i][2])
                    {
                        nextNode = PathGraph[i][1];
                        resultantPaths[counter] = PathGraph[i][2];
                        prev = PathGraph[i][2];
                        if(nextNode == dest){
                            break PathSequence;
                        }
                        counter++;
                    }
                }

                if(nextNode == PathGraph[i][0] && prev != PathGraph[i][2]){
                    nextNode = PathGraph[i][1];
                    resultantPaths[counter] = PathGraph[i][2];
                    prev = PathGraph[i][2];
                    if(nextNode == dest){
                        break PathSequence;
                    }
                    counter++;                    
                }

                if(i == PathGraphRow-1 && PathGraph[i][2] != resultantPaths[counter]){
                    if(PathGraph[i][1] != dest){
                        resultantPaths = new int[PathCount];
                    }
                }

            }        
    }

路径序列：
for（int i=0；i0&&prev！=路径图[i][2]）
{
nextNode=PathGraph[i][1]；
结果路径[计数器]=路径图[i][2]；
prev=路径图[i][2]；
if（nextNode==dest）{
中断路径序列；
}
计数器++；
}
}
if（nextNode==路径图[i][0]&&prev！=路径图[i][2]）{
nextNode=PathGraph[i][1]；
结果路径[计数器]=路径图[i][2]；
prev=路径图[i][2]；
if（nextNode==dest）{
中断路径序列；
}
计数器++；
}
if（i==PathGraphRow-1&&PathGraph[i][2]！=ResultantPath[counter]）{
if（路径图[i][1]！=dest）{
ResultantPath=newint[PathCount]；
}
}
}        
}

多谢各位

---

关于

除非我忽略了一些细节，否则如果没有子路径，问题就相当微不足道了。您只需要一个非常具体的for循环

 for (int i = 0; i < columns; i++)
 {
      Path path = new Path(array[i][0], array[i][1], array[i][2]);
      pathsArray.Add(path);
 }

---

您肯定需要一个嵌套的for循环，外部循环遍历列，内部循环遍历当前行。除此之外，我不知道你在问什么。整数数组如何存储

2->4=502

？这毫无意义。听起来你在试图从一种不合适的存储方法变成一种更糟糕的存储方法。你想过做一个3d数组吗？我猜你实际上不是在寻找一个一维数组，而是一个图形。我建议你去学习一种叫做graph的数据结构。@melpomene，这实际上是有意义的，但问题是一个一维整数数组。它实际上应该是元组，因为顺序很重要，它们应该是4个元组，因为可能有三个值导致一个（如果实际数据集与发布的数据集不同，则可能有多个）。元组中的第三个值应该是

null

或

-1

或其他值，如果它只需要两个值，比如

2->4=500

@evanmcdonnal，我不理解4元组位，但1D数组是输出（路径ID列表）。我描述的是输入（图形结构）。

int[] paths = new int[2dArray.length * 3];
int mapper = 0;

for (int i = 0; i < 2dArray.length; i++)
{
     paths[mapper] = 2dArray[i][0];
     paths[mapper + 1] = 2dArray[i][1];
     paths[mapper + 2] = 2dArray[i][2];
     mapper += 3;
}

 if (index % 3 == 0)
    //path start
 else if (index % 3 == 1)
    //path end
 else if (index % 3 == 2)
    // result of path