使用while循环迭代遍历图

Question

我正在使用cytoscape.js 创建图表。

我想穿过节点（有方向），但只到那些与包含特定值的边相连的节点。

我已经用这样的递归做到了

function traverse(node, requiredValue, visitedNodes) {
  // break if we visit a node twice
  if (visitedNodes.map(visitedNode => visitedNode.id()).includes(node.id())) {
    return visitedNodes;
  }

  // add visited node to collection
  visitedNodes.push(node);

  // select node
  node.select();

  // only travel through valid edges
  const edgesTo = node.outgoers(function () {
    return this.isEdge() && this.data('requiredValues').includes(requiredValue);
  });

  // break if no valid connected edges
  if (edgesTo.empty()) {
    return visitedNodes;
  }

  // travel through edges
  edgesTo.forEach(edge => {
    edge.select()
    return traverse(edge.target(), agent, visitedNodes);
  });
}

它似乎有效，但我不太擅长算法，所以我不确定这是否是构建它的聪明方法。我读过一些关于广度优先和深度优先搜索算法的文章，但我不确定是否是我需要的那些算法。

是否可以在不使用递归的情况下遍历树？我也尝试过使用while 循环，但由于它是一棵树，我认为我不能只使用

node = rootNode;

while (true) {
  // find leaving edges
  ...

  edgesTo.forEach(edge => {
    // set new node to traverse
    node = edge.target;
  }
}

因为我猜edgesTo.forEach() 将在进入while 循环中的下一个迭代之前完成。我需要它“同时”遍历不同的分支。

我可以从http://js.cytoscape.org/#collection/algorithms 看到该库有多种算法（包括 bfs 和 dfs），但是当我想遍历树而不是搜索特定节点时是否需要这些算法？

Answer 1

BFS 和 DFS 是通用的图遍历算法。它们不仅用于搜索某些特定节点。很多算法都有 BFS 和 DFS 作为子程序。

您的代码基本上在图表上执行 DFS。您将忽略所有不需要的边并以深度优先的方式遍历图形的其余部分。

是的，可以同时使用 DFS 和 BFS 遍历图形而无需递归，并且只使用一些特定的边。你只需要忽略不需要的边缘。

BFS:

Breadth-First-Search(Graph, root):
     create empty queue Q       
     visited.put(root)
     Q.enqueue(root)                      
     while Q is not empty:             
        current = Q.dequeue()     
        for each edge that edge.startpoint == current:
             if current has required value AND edge.endpoint is not in visited:
                 Q.enqueue(edge.endpoint)
                 visited.put(edge.endpoint)

DFS:

procedure DFS-iterative(G,v):
      let S be a stack
      S.push(v)
      while S is not empty:
          v = S.pop()
          if v is not labeled as discovered:
              label v as discovered
              for all edges from v to w in G.adjacentEdges(v) :
                  if edge has required value:
                       S.push(w)

Answer 2

我将把我的答案分解为您明确或隐含地提出的几个问题：

一般的 BFS 和 DFS 算法

BFS 和 DFS 是遍历连接图（或图的连接组件）的算法。它们允许您从特定的起始节点访问 所有 连接的节点（它们不会像您暗示的那样搜索特定节点，尽管它们可以以这种方式使用），并且顺序不同他们遍历图（Breadth-Frist，意味着在进入下一层邻居之前访问一个节点的所有直接邻居，与 Depth-First 相比，这意味着首先追求一个从一个直接邻居开始并更深入的分支，在继续下一个分支之前访问所有通过该特定邻居节点连接到起始节点的节点，这些节点是通过下一个直接邻居连接的所有节点。

与您的要求相关的 BFS 和 DFS

和以前一样，这两种算法都会访问图的连接组件中的所有节点（通过遍历边可以从起始节点到达的所有节点）。由于您有不同的要求（仅使用特定值的边进行遍历），我建议您自己更改任一算法，并添加此需求。您实际上已经这样做了：您的算法在某种意义上是 DFS 的后代/版本。

BFS 和 DFS 以及递归

BFSdoes not normally include recursion并使用数据结构（队列）来实现其遍历顺序。

DFS 很容易通过递归实现（您实现算法的直观方式与此非常相似）。但是您可以在没有递归的情况下实现 DFS - 使用数据结构（堆栈）来实现其遍历顺序（本质上，递归隐式使用调用堆栈作为数据结构，因此它没有那么不同，尽管递归有更多的开销来处理与函数调用及其环境）。 您可以在wiki of DFS 中看到一个伪代码。这里是为了方便：

procedure DFS-iterative(G,v):
  let S be a stack
  S.push(v)
  while S is not empty
      v = S.pop()
      if v is not labeled as discovered:
          label v as discovered
          for all edges from v to w in G.adjacentEdges(v) do
              S.push(w)

Answer 3

Cytoscape 包含许多开箱即用的common graph theory algorithms。这些算法甚至可以让您指定要包含/调用的元素。

您可以使用像.outgoers() 这样的低级遍历 API 自己重新实现 BFS 遍历算法，但为什么要重新发明轮子呢？

BFS 和 DFS 内置于 Cytoscape：

cy.elements().stdFilter(function( ele ){
  return ele.isNode() ? includeThisNode( ele ) : includeThisEdge( ele ); // eles to include
}).bfs({
  visit: function(){ ... } // called when new ele visited
});

指定 includeThisNode() 和 includeThisEdge() 以满足您应该允许遍历哪些元素的标准。

如果您有具有特定条件的目标节点，则在满足这些条件时在 visit() 中返回 true。