web-dev-qa-db-ja.com

非再帰的深さ優先探索アルゴリズム

非バイナリツリーの非再帰的深さ優先探索アルゴリズムを探しています。どんな助けも大歓迎です。

algorithmtree
157
mousey

DFS：

list nodes_to_visit = {root};
while( nodes_to_visit isn't empty ) {
  currentnode = nodes_to_visit.take_first();
  nodes_to_visit.prepend( currentnode.children );
  //do something
}

BFS：

list nodes_to_visit = {root};
while( nodes_to_visit isn't empty ) {
  currentnode = nodes_to_visit.take_first();
  nodes_to_visit.append( currentnode.children );
  //do something
}

2つの対称性は非常に優れています。

更新：指摘したように、take_first()はリストの最初の要素を削除して返します。

284
biziclop

まだアクセスされていないノードを保持する stack を使用します。

stack.Push(root)
while !stack.isEmpty() do
    node = stack.pop()
    for each node.childNodes do
        stack.Push(stack)
    endfor
    // …
endwhile
37
Gumbo

親ノードへのポインターがある場合は、追加のメモリーなしでそれを行うことができます。

def dfs(root):
    node = root
    while True:
        visit(node)
        if node.first_child:
            node = node.first_child      # walk down
        else:
            while not node.next_sibling:
                if node is root:
                    return
                node = node.parent       # walk up ...
            node = node.next_sibling     # ... and right

子ノードが兄弟ポインターではなく配列として格納されている場合、次の兄弟は次のように見つかることに注意してください。

def next_sibling(node):
    try:
        i =    node.parent.child_nodes.index(node)
        return node.parent.child_nodes[i+1]
    except (IndexError, AttributeError):
        return None
31
aaz

スタックを使用してノードを追跡する

Stack<Node> s;

s.prepend(tree.head);

while(!s.empty) {
    Node n = s.poll_front // gets first node

    // do something with q?

    for each child of n: s.prepend(child)

}
5
corsiKa

Biziclopsに基づくES6の実装の素晴らしい答え：

root = {
  text: "root",
  children: [{
    text: "c1",
    children: [{
      text: "c11"
    }, {
      text: "c12"
    }]
  }, {
    text: "c2",
    children: [{
      text: "c21"
    }, {
      text: "c22"
    }]
  }, ]
}

console.log("DFS:")
DFS(root, node => node.children, node => console.log(node.text));

console.log("BFS:")
BFS(root, node => node.children, node => console.log(node.text));

function BFS(root, getChildren, visit) {
  let nodesToVisit = [root];
  while (nodesToVisit.length > 0) {
    const currentNode = nodesToVisit.shift();
    nodesToVisit = [
      ...nodesToVisit,
      ...(getChildren(currentNode) || []),
    ];
    visit(currentNode);
  }
}

function DFS(root, getChildren, visit) {
  let nodesToVisit = [root];
  while (nodesToVisit.length > 0) {
    const currentNode = nodesToVisit.shift();
    nodesToVisit = [
      ...(getChildren(currentNode) || []),
      ...nodesToVisit,
    ];
    visit(currentNode);
  }
}
4
Max Leizerovich

「スタックを使用する」mightは、不自然なインタビューの質問に対する答えとして機能しますが、実際には、再帰プログラムが舞台裏で行うことを明示的に行っています。

再帰は、プログラムの組み込みスタックを使用します。関数を呼び出すと、関数の引数がスタックにプッシュされ、関数が戻ると、プログラムスタックがポップされます。

3
Chris Bennet

ES6ジェネレーターを使用した非再帰的DFS

class Node {
  constructor(name, childNodes) {
    this.name = name;
    this.childNodes = childNodes;
    this.visited = false;
  }
}

function *dfs(s) {
  let stack = [];
  stack.Push(s);
  stackLoop: while (stack.length) {
    let u = stack[stack.length - 1]; // peek
    if (!u.visited) {
      u.visited = true; // grey - visited
      yield u;
    }

    for (let v of u.childNodes) {
      if (!v.visited) {
        stack.Push(v);
        continue stackLoop;
      }
    }

    stack.pop(); // black - all reachable descendants were processed 
  }    
}

通常の非再帰的DFS から逸脱し、指定されたノードのすべての到達可能な子孫がいつ処理されたかを簡単に検出し、リスト/スタック内の現在のパスを維持します。

2
Jarek Przygódzki
PreOrderTraversal is same as DFS in binary tree. You can do the same recursion 
taking care of Stack as below.

    public void IterativePreOrder(Tree root)
            {
                if (root == null)
                    return;
                Stack s<Tree> = new Stack<Tree>();
                s.Push(root);
                while (s.Count != 0)
                {
                    Tree b = s.Pop();
                    Console.Write(b.Data + " ");
                    if (b.Right != null)
                        s.Push(b.Right);
                    if (b.Left != null)
                        s.Push(b.Left);

                }
            }

一般的なロジックは、（ルートから始まる）ノードをStackにプッシュし、Pop（）itとPrint（）値です。次に、子がある場合（左と右）スタックにプッシュします-最初に右にプッシュして、左の子に最初にアクセスします（ノード自体にアクセスした後）。 stackがempty（）の場合、事前注文ですべてのノードを訪問します。

2
Sanj

スタックなしの完全なサンプルWORKINGコード：

import Java.util.*;

class Graph {
private List<List<Integer>> adj;

Graph(int numOfVertices) {
    this.adj = new ArrayList<>();
    for (int i = 0; i < numOfVertices; ++i)
        adj.add(i, new ArrayList<>());
}

void addEdge(int v, int w) {
    adj.get(v).add(w); // Add w to v's list.
}

void DFS(int v) {
    int nodesToVisitIndex = 0;
    List<Integer> nodesToVisit = new ArrayList<>();
    nodesToVisit.add(v);
    while (nodesToVisitIndex < nodesToVisit.size()) {
        Integer nextChild= nodesToVisit.get(nodesToVisitIndex++);// get the node and mark it as visited node by inc the index over the element.
        for (Integer s : adj.get(nextChild)) {
            if (!nodesToVisit.contains(s)) {
                nodesToVisit.add(nodesToVisitIndex, s);// add the node to the HEAD of the unvisited nodes list.
            }
        }
        System.out.println(nextChild);
    }
}

void BFS(int v) {
    int nodesToVisitIndex = 0;
    List<Integer> nodesToVisit = new ArrayList<>();
    nodesToVisit.add(v);
    while (nodesToVisitIndex < nodesToVisit.size()) {
        Integer nextChild= nodesToVisit.get(nodesToVisitIndex++);// get the node and mark it as visited node by inc the index over the element.
        for (Integer s : adj.get(nextChild)) {
            if (!nodesToVisit.contains(s)) {
                nodesToVisit.add(s);// add the node to the END of the unvisited node list.
            }
        }
        System.out.println(nextChild);
    }
}

public static void main(String args[]) {
    Graph g = new Graph(5);

    g.addEdge(0, 1);
    g.addEdge(0, 2);
    g.addEdge(1, 2);
    g.addEdge(2, 0);
    g.addEdge(2, 3);
    g.addEdge(3, 3);
    g.addEdge(3, 1);
    g.addEdge(3, 4);

    System.out.println("Breadth First Traversal- starting from vertex 2:");
    g.BFS(2);
    System.out.println("Depth First Traversal- starting from vertex 2:");
    g.DFS(2);
}}

出力：幅の最初の走査-頂点2から開始：2 0 3 1 4深さの最初の走査-頂点2から開始：2 3 4 1 0

1
Assaf Faybish

グラフ内の各ノードにアクセスしたときに通知を実行するとします。単純な再帰的実装は次のとおりです。

void DFSRecursive(Node n, Set<Node> visited) {
  visited.add(n);
  for (Node x : neighbors_of(n)) {  // iterate over all neighbors
    if (!visited.contains(x)) {
      DFSRecursive(x, visited);
    }
  }
  OnVisit(n);  // callback to say node is finally visited, after all its non-visited neighbors
}

さて、あなたの例が機能しないため、スタックベースの実装が必要になりました。複雑なグラフは、例えば、これがあなたのプログラムのスタックを吹き飛ばし、非再帰的なバージョンを実装する必要があるかもしれません。最大の問題は、いつ通知を発行するかを知ることです。

次の擬似コードが機能します（読みやすいようにJavaとC++を組み合わせています）：

void DFS(Node root) {
  Set<Node> visited;
  Set<Node> toNotify;  // nodes we want to notify

  Stack<Node> stack;
  stack.add(root);
  toNotify.add(root);  // we won't pop nodes from this until DFS is done
  while (!stack.empty()) {
    Node current = stack.pop();
    visited.add(current);
    for (Node x : neighbors_of(current)) {
      if (!visited.contains(x)) {
        stack.add(x);
        toNotify.add(x);
      }
    }
  }
  // Now issue notifications. toNotifyStack might contain duplicates (will never
  // happen in a tree but easily happens in a graph)
  Set<Node> notified;
  while (!toNotify.empty()) {
  Node n = toNotify.pop();
  if (!toNotify.contains(n)) {
    OnVisit(n);  // issue callback
    toNotify.add(n);
  }
}

複雑に見えますが、訪問の逆順で通知する必要があるため、通知を発行するために必要な追加のロジックが存在します-実装が非常に簡単なBFSとは異なり、DFSはルートから始まり最後に通知します.

キックについては、次のグラフを試してください。ノードはs、t、v、wです。有向エッジは、s-> t、s-> v、t-> w、v-> w、およびv-> tです。 DFSの独自の実装を実行し、ノードを訪問する順序は次のとおりである必要があります：w、t、v、s DFSの不器用な実装は、最初にtに通知することがあり、それはバグを示します。 DFSの再帰的な実装は、常に最後にwに達します。

1
user3804051

Stackを使用して、次の手順を実行します。スタックの最初の頂点をプッシュし、

  1. 可能であれば、隣接する未訪問の頂点にアクセスしてマークを付け、スタックにプッシュします。
  2. 手順1を実行できない場合は、可能であれば、スタックから頂点をポップします。
  3. ステップ1またはステップ2を実行できない場合は、完了です。

上記の手順に従ったJavaプログラムは次のとおりです。

public void searchDepthFirst() {
    // begin at vertex 0
    vertexList[0].wasVisited = true;
    displayVertex(0);
    stack.Push(0);
    while (!stack.isEmpty()) {
        int adjacentVertex = getAdjacentUnvisitedVertex(stack.peek());
        // if no such vertex
        if (adjacentVertex == -1) {
            stack.pop();
        } else {
            vertexList[adjacentVertex].wasVisited = true;
            // Do something
            stack.Push(adjacentVertex);
        }
    }
    // stack is empty, so we're done, reset flags
    for (int j = 0; j < nVerts; j++)
            vertexList[j].wasVisited = false;
}
0
Yogesh Umesh Vaity
        Stack<Node> stack = new Stack<>();
        stack.add(root);
        while (!stack.isEmpty()) {
            Node node = stack.pop();
            System.out.print(node.getData() + " ");

            Node right = node.getRight();
            if (right != null) {
                stack.Push(right);
            }

            Node left = node.getLeft();
            if (left != null) {
                stack.Push(left);
            }
        }
0
iMobaio

スタックを使用できます。隣接行列でグラフを実装しました：

void DFS(int current){
    for(int i=1; i<N; i++) visit_table[i]=false;
    myStack.Push(current);
    cout << current << "  ";
    while(!myStack.empty()){
        current = myStack.top();
        for(int i=0; i<N; i++){
            if(AdjMatrix[current][i] == 1){
                if(visit_table[i] == false){ 
                    myStack.Push(i);
                    visit_table[i] = true;
                    cout << i << "  ";
                }
                break;
            }
            else if(!myStack.empty())
                myStack.pop();
        }
    }
}
0
noDispName

JavaでのDFS反復：

//DFS: Iterative
private Boolean DFSIterative(Node root, int target) {
    if (root == null)
        return false;
    Stack<Node> _stack = new Stack<Node>();
    _stack.Push(root);
    while (_stack.size() > 0) {
        Node temp = _stack.peek();
        if (temp.data == target)
            return true;
        if (temp.left != null)
            _stack.Push(temp.left);
        else if (temp.right != null)
            _stack.Push(temp.right);
        else
            _stack.pop();
    }
    return false;
}
0
Piyush Patel

@biziclopの回答に基づく擬似コード：

  • 基本的な構成要素のみを使用：変数、配列、if、while、for
  • 関数getNode(id)およびgetChildren(id)
  • 既知のノード数を想定するN

注：0ではなく1からの配列インデックスを使用しています

幅優先

S = Array(N)
S[1] = 1; // root id
cur = 1;
last = 1
while cur <= last
    id = S[cur]
    node = getNode(id)
    children = getChildren(id)

    n = length(children)
    for i = 1..n
        S[ last+i ] = children[i]
    end
    last = last+n
    cur = cur+1

    visit(node)
end

深さ優先

S = Array(N)
S[1] = 1; // root id
cur = 1;
while cur > 0
    id = S[cur]
    node = getNode(id)
    children = getChildren(id)

    n = length(children)
    for i = 1..n
        // assuming children are given left-to-right
        S[ cur+i-1 ] = children[ n-i+1 ] 

        // otherwise
        // S[ cur+i-1 ] = children[i] 
    end
    cur = cur+n-1

    visit(node)
end
0
Sheljohn

http://www.youtube.com/watch?v=zLZhSSXAwxI

このビデオをご覧になり、実装してください。私には理解しやすいようです。これを批判してください。

visited_node={root}
stack.Push(root)
while(!stack.empty){
  unvisited_node = get_unvisited_adj_nodes(stack.top());
  If (unvisited_node!=null){
     stack.Push(unvisited_node);  
     visited_node+=unvisited_node;
  }
  else
     stack.pop()
}
0
prog_guy