（これはある種の思考運動、またはトリックの宿題/インタビューの質問でさえあると仮定していますが、何らかの理由でヒープスペースが許可されていない奇妙なシナリオを想像できると思いますメモリマネージャー？いくつかの奇妙なランタイム/ OSの問題？]まだスタックにアクセスしている間に...）
幅優先のトラバーサルでは、伝統的にスタックではなくキューを使用します。キューとスタックの性質はほぼ反対であるため、コールスタック（スタックであるため名前）を補助記憶装置（キュー）として使用しようとすると、失敗する可能性が非常に高くなります。コールスタックでばかげてばかげたことをしてはいけません。
同じトークンで、実装しようとする非末尾再帰の性質は、基本的にアルゴリズムにスタックを追加することです。これにより、バイナリツリーでの幅優先検索が行われなくなるため、従来のBFSのランタイムやその他は完全に適用されなくなります。もちろん、ループをいつでも再帰呼び出しに簡単に変えることができますが、それは意味のある再帰ではありません。
ただし、BFSのセマンティクスに従うものをいくらかコストをかけて実装する方法は、他の人によって実証されているようにあります。比較のコストは高いが、ノードトラバーサルは安い場合、 @ Simon Buchan のように、葉だけを処理する反復的な深さ優先検索を実行できます。これは、ヒープに格納されているキューが成長せず、ローカルの深さ変数のみであり、ツリーが何度も走査されるときに呼び出しスタック上にスタックが繰り返し構築されることを意味します。 @ Patrick のように、配列に裏打ちされたバイナリツリーは通常、幅優先の走査順序で保存されるので、幅優先の検索は補助キューを必要とせずに簡単になります。
配列を使用してバイナリツリーをバックアップする場合、次のノードを代数的に決定できます。 iがノードの場合、その子は2i + 1（左側のノード）および2i + 2（右側のノード）にあります。 iがi + 1の累乗でない限り、ノードの次の隣接ノードは2で与えられます
以下は、配列に裏付けされたバイナリ検索ツリーでの幅優先検索の非常に単純な実装の擬似コードです。これは、固定サイズの配列、したがって固定深さツリーを想定しています。親のないノードを調べ、管理できないほど大きなスタックを作成する可能性があります。
bintree-bfs(bintree, elt, i)
if (i == LENGTH)
return false
else if (bintree[i] == elt)
return true
else
return bintree-bfs(bintree, elt, i+1)
私はそれを完全に再帰的に行う方法を見つけることができませんでした（補助的なデータ構造なしで）。ただし、キューQが参照で渡される場合、次の愚かな末尾再帰関数を使用できます。
BFS(Q)
{
if (|Q| > 0)
v <- Dequeue(Q)
Traverse(v)
foreach w in children(v)
Enqueue(Q, w)
BFS(Q)
}
次の方法では、DFSアルゴリズムを使用して特定の深さのすべてのノードを取得しました。これは、そのレベルでBFSを実行するのと同じです。ツリーの深さを見つけて、すべてのレベルでこれを行うと、結果はBFSと同じになります。
public void PrintLevelNodes(Tree root, int level) {
if (root != null) {
if (level == 0) {
Console.Write(root.Data);
return;
}
PrintLevelNodes(root.Left, level - 1);
PrintLevelNodes(root.Right, level - 1);
}
}
for (int i = 0; i < depth; i++) {
PrintLevelNodes(root, i);
}
木の深さを見つけることは簡単です：
public int MaxDepth(Tree root) {
if (root == null) {
return 0;
} else {
return Math.Max(MaxDepth(root.Left), MaxDepth(root.Right)) + 1;
}
}
Javaでの単純なBFSおよびDFS再帰：
スタック/キューでツリーのルートノードをプッシュ/オファーし、これらの関数を呼び出します。
public static void breadthFirstSearch(Queue queue) {
if (queue.isEmpty())
return;
Node node = (Node) queue.poll();
System.out.println(node + " ");
if (node.right != null)
queue.offer(node.right);
if (node.left != null)
queue.offer(node.left);
breadthFirstSearch(queue);
}
public static void depthFirstSearch(Stack stack) {
if (stack.isEmpty())
return;
Node node = (Node) stack.pop();
System.out.println(node + " ");
if (node.right != null)
stack.Push(node.right);
if (node.left != null)
stack.Push(node.left);
depthFirstSearch(stack);
}
愚かな方法：
template<typename T>
struct Node { Node* left; Node* right; T value; };
template<typename T, typename P>
bool searchNodeDepth(Node<T>* node, Node<T>** result, int depth, P pred) {
if (!node) return false;
if (!depth) {
if (pred(node->value)) {
*result = node;
}
return true;
}
--depth;
searchNodeDepth(node->left, result, depth, pred);
if (!*result)
searchNodeDepth(node->right, result, depth, pred);
return true;
}
template<typename T, typename P>
Node<T>* searchNode(Node<T>* node, P pred) {
Node<T>* result = NULL;
int depth = 0;
while (searchNodeDepth(node, &result, depth, pred) && !result)
++depth;
return result;
}
int main()
{
// a c f
// b e
// d
Node<char*>
a = { NULL, NULL, "A" },
c = { NULL, NULL, "C" },
b = { &a, &c, "B" },
f = { NULL, NULL, "F" },
e = { NULL, &f, "E" },
d = { &b, &e, "D" };
Node<char*>* found = searchNode(&d, [](char* value) -> bool {
printf("%s\n", value);
return !strcmp((char*)value, "F");
});
printf("found: %s\n", found->value);
return 0;
}
私は、非常に美しい再帰的（機能的でさえある）幅優先トラバーサル関連アルゴリズムを見つけました。私の考えではありませんが、このトピックで言及すべきだと思います。
Chris Okasakiは、ICFP 2000の幅優先ナンバリングアルゴリズムについて http://okasaki.blogspot.de/2008/07/breadth-first-numbering-algorithm-in.html で説明しています。ピクチャー。
http://debasishg.blogspot.de/2008/09/breadth-first-numbering-okasakis.html で見つけたDebasish GhoshのScala実装は：
trait Tree[+T]
case class Node[+T](data: T, left: Tree[T], right: Tree[T]) extends Tree[T]
case object E extends Tree[Nothing]
def bfsNumForest[T](i: Int, trees: Queue[Tree[T]]): Queue[Tree[Int]] = {
if (trees.isEmpty) Queue.Empty
else {
trees.dequeue match {
case (E, ts) =>
bfsNumForest(i, ts).enqueue[Tree[Int]](E)
case (Node(d, l, r), ts) =>
val q = ts.enqueue(l, r)
val qq = bfsNumForest(i+1, q)
val (bb, qqq) = qq.dequeue
val (aa, tss) = qqq.dequeue
tss.enqueue[org.dg.collection.BFSNumber.Tree[Int]](Node(i, aa, bb))
}
}
}
def bfsNumTree[T](t: Tree[T]): Tree[Int] = {
val q = Queue.Empty.enqueue[Tree[T]](t)
val qq = bfsNumForest(1, q)
qq.dequeue._1
}
再帰的BFSのScala 2.11.4実装です。簡潔にするためにテールコールの最適化を犠牲にしましたが、TCOdバージョンは非常に似ています。 @ snv の投稿も参照してください。
import scala.collection.immutable.Queue
object RecursiveBfs {
def bfs[A](tree: Tree[A], target: A): Boolean = {
bfs(Queue(tree), target)
}
private def bfs[A](forest: Queue[Tree[A]], target: A): Boolean = {
forest.dequeueOption exists {
case (E, tail) => bfs(tail, target)
case (Node(value, _, _), _) if value == target => true
case (Node(_, l, r), tail) => bfs(tail.enqueue(List(l, r)), target)
}
}
sealed trait Tree[+A]
case class Node[+A](data: A, left: Tree[A], right: Tree[A]) extends Tree[A]
case object E extends Tree[Nothing]
}
ここに短いScalaソリューションがあります：
def bfs(nodes: List[Node]): List[Node] = {
if (nodes.nonEmpty) {
nodes ++ bfs(nodes.flatMap(_.children))
} else {
List.empty
}
}
戻り値をアキュムレータとして使用のアイデアが適しています。同様の方法で他の言語で実装できます。再帰関数プロセスノードのリストであることを確認してください。
テストコードリスト（@marcoテストツリーを使用）：
import org.scalatest.FlatSpec
import scala.collection.mutable
class Node(val value: Int) {
private val _children: mutable.ArrayBuffer[Node] = mutable.ArrayBuffer.empty
def add(child: Node): Unit = _children += child
def children = _children.toList
override def toString: String = s"$value"
}
class BfsTestScala extends FlatSpec {
// 1
// / | \
// 2 3 4
// / | | \
// 5 6 7 8
// / | | \
// 9 10 11 12
def tree(): Node = {
val root = new Node(1)
root.add(new Node(2))
root.add(new Node(3))
root.add(new Node(4))
root.children(0).add(new Node(5))
root.children(0).add(new Node(6))
root.children(2).add(new Node(7))
root.children(2).add(new Node(8))
root.children(0).children(0).add(new Node(9))
root.children(0).children(0).add(new Node(10))
root.children(2).children(0).add(new Node(11))
root.children(2).children(0).add(new Node(12))
root
}
def bfs(nodes: List[Node]): List[Node] = {
if (nodes.nonEmpty) {
nodes ++ bfs(nodes.flatMap(_.children))
} else {
List.empty
}
}
"BFS" should "work" in {
println(bfs(List(tree())))
}
}
出力：
List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
python実装は次のとおりです。
graph = {'A': ['B', 'C'],
'B': ['C', 'D'],
'C': ['D'],
'D': ['C'],
'E': ['F'],
'F': ['C']}
def bfs(paths, goal):
if not paths:
raise StopIteration
new_paths = []
for path in paths:
if path[-1] == goal:
yield path
last = path[-1]
for neighbor in graph[last]:
if neighbor not in path:
new_paths.append(path + [neighbor])
yield from bfs(new_paths, goal)
for path in bfs([['A']], 'D'):
print(path)
Haskellを使用すると、次のことがかなり自然に思えます。ツリーのレベルを再帰的に繰り返します（ここでは、ツリー内のパスを示すために名前を大きな順序付き文字列に収集します）。
data Node = Node {name :: String, children :: [Node]}
aTree = Node "r" [Node "c1" [Node "gc1" [Node "ggc1" []], Node "gc2" []] , Node "c2" [Node "gc3" []], Node "c3" [] ]
breadthFirstOrder x = levelRecurser [x]
where levelRecurser level = if length level == 0
then ""
else concat [name node ++ " " | node <- level] ++ levelRecurser (concat [children node | node <- level])
バイナリ（またはn項）ツリーのBFSは、次のようにキューなしで再帰的に実行できます（ここではJava）。
public class BreathFirst {
static class Node {
Node(int value) {
this(value, 0);
}
Node(int value, int nChildren) {
this.value = value;
this.children = new Node[nChildren];
}
int value;
Node[] children;
}
static void breathFirst(Node root, Consumer<? super Node> printer) {
boolean keepGoing = true;
for (int level = 0; keepGoing; level++) {
keepGoing = breathFirst(root, printer, level);
}
}
static boolean breathFirst(Node node, Consumer<? super Node> printer, int depth) {
if (depth < 0 || node == null) return false;
if (depth == 0) {
printer.accept(node);
return true;
}
boolean any = false;
for (final Node child : node.children) {
any |= breathFirst(child, printer, depth - 1);
}
return any;
}
}
1から12までの昇順でのトラバーサル印刷の例：
public static void main(String... args) {
// 1
// / | \
// 2 3 4
// / | | \
// 5 6 7 8
// / | | \
// 9 10 11 12
Node root = new Node(1, 3);
root.children[0] = new Node(2, 2);
root.children[1] = new Node(3);
root.children[2] = new Node(4, 2);
root.children[0].children[0] = new Node(5, 2);
root.children[0].children[1] = new Node(6);
root.children[2].children[0] = new Node(7, 2);
root.children[2].children[1] = new Node(8);
root.children[0].children[0].children[0] = new Node(9);
root.children[0].children[0].children[1] = new Node(10);
root.children[2].children[0].children[0] = new Node(11);
root.children[2].children[0].children[1] = new Node(12);
breathFirst(root, n -> System.out.println(n.value));
}
Vを開始頂点とする
Gを問題のグラフとする
以下は、キューを使用しない擬似コードです
Initially label v as visited as you start from v
BFS(G,v)
for all adjacent vertices w of v in G:
if vertex w is not visited:
label w as visited
for all adjacent vertices w of v in G:
recursively call BFS(G,w)
BFS順序で出力するヒープトラバーサルを実装する必要がありました。実際にはBFSではありませんが、同じタスクを実行します。
private void getNodeValue(Node node, int index, int[] array) {
array[index] = node.value;
index = (index*2)+1;
Node left = node.leftNode;
if (left!=null) getNodeValue(left,index,array);
Node right = node.rightNode;
if (right!=null) getNodeValue(right,index+1,array);
}
public int[] getHeap() {
int[] nodes = new int[size];
getNodeValue(root,0,nodes);
return nodes;
}
#include <bits/stdc++.h>
using namespace std;
#define Max 1000
vector <int> adj[Max];
bool visited[Max];
void bfs_recursion_utils(queue<int>& Q) {
while(!Q.empty()) {
int u = Q.front();
visited[u] = true;
cout << u << endl;
Q.pop();
for(int i = 0; i < (int)adj[u].size(); ++i) {
int v = adj[u][i];
if(!visited[v])
Q.Push(v), visited[v] = true;
}
bfs_recursion_utils(Q);
}
}
void bfs_recursion(int source, queue <int>& Q) {
memset(visited, false, sizeof visited);
Q.Push(source);
bfs_recursion_utils(Q);
}
int main(void) {
queue <int> Q;
adj[1].Push_back(2);
adj[1].Push_back(3);
adj[1].Push_back(4);
adj[2].Push_back(5);
adj[2].Push_back(6);
adj[3].Push_back(7);
bfs_recursion(1, Q);
return 0;
}
以下は、ループとキューを使用せずに双方向グラフの幅優先探索を完全に再帰的に実装するための私のコードです。
public class Graph
{
public int V;
public LinkedList<Integer> adj[];
Graph(int v)
{
V = v;
adj = new LinkedList[v];
for (int i=0; i<v; ++i)
adj[i] = new LinkedList<>();
}
void addEdge(int v,int w)
{
adj[v].add(w);
adj[w].add(v);
}
public LinkedList<Integer> getAdjVerted(int vertex)
{
return adj[vertex];
}
public String toString()
{
String s = "";
for (int i=0;i<adj.length;i++)
{
s = s +"\n"+i +"-->"+ adj[i] ;
}
return s;
}
}
//BFS IMPLEMENTATION
public static void recursiveBFS(Graph graph, int vertex,boolean visited[], boolean isAdjPrinted[])
{
if (!visited[vertex])
{
System.out.print(vertex +" ");
visited[vertex] = true;
}
if(!isAdjPrinted[vertex])
{
isAdjPrinted[vertex] = true;
List<Integer> adjList = graph.getAdjVerted(vertex);
printAdjecent(graph, adjList, visited, 0,isAdjPrinted);
}
}
public static void recursiveBFS(Graph graph, List<Integer> vertexList, boolean visited[], int i, boolean isAdjPrinted[])
{
if (i < vertexList.size())
{
recursiveBFS(graph, vertexList.get(i), visited, isAdjPrinted);
recursiveBFS(graph, vertexList, visited, i+1, isAdjPrinted);
}
}
public static void printAdjecent(Graph graph, List<Integer> list, boolean visited[], int i, boolean isAdjPrinted[])
{
if (i < list.size())
{
if (!visited[list.get(i)])
{
System.out.print(list.get(i)+" ");
visited[list.get(i)] = true;
}
printAdjecent(graph, list, visited, i+1, isAdjPrinted);
}
else
{
recursiveBFS(graph, list, visited, 0, isAdjPrinted);
}
}
以下は、BFS再帰トラバーサルPython実装であり、サイクルのないグラフで機能します。
def bfs_recursive(level):
'''
@params level: List<Node> containing the node for a specific level.
'''
next_level = []
for node in level:
print(node.value)
for child_node in node.adjency_list:
next_level.append(child_node)
if len(next_level) != 0:
bfs_recursive(next_level)
class Node:
def __init__(self, value):
self.value = value
self.adjency_list = []
以下は、深さ優先再帰で幅優先走査を偽装するJavaScript実装です。配列内、ハッシュ内の各深さでノード値を保存しています。レベルが既に存在する場合（衝突がある場合）、そのレベルの配列にプッシュするだけです。レベルは数値であり、配列のインデックスとして機能するため、JavaScriptオブジェクトの代わりに配列を使用することもできます。ノード、値を返したり、リンクリストに変換したり、必要に応じて変換したりできます。単純にするために値を返すだけです。
BinarySearchTree.prototype.breadthFirstRec = function() {
var levels = {};
var traverse = function(current, depth) {
if (!current) return null;
if (!levels[depth]) levels[depth] = [current.value];
else levels[depth].Push(current.value);
traverse(current.left, depth + 1);
traverse(current.right, depth + 1);
};
traverse(this.root, 0);
return levels;
};
var bst = new BinarySearchTree();
bst.add(20, 22, 8, 4, 12, 10, 14, 24);
console.log('Recursive Breadth First: ', bst.breadthFirstRec());
/*Recursive Breadth First:
{ '0': [ 20 ],
'1': [ 8, 22 ],
'2': [ 4, 12, 24 ],
'3': [ 10, 14 ] } */
反復アプローチを使用した実際のBreadth First Traversalの例を次に示します。
BinarySearchTree.prototype.breadthFirst = function() {
var result = '',
queue = [],
current = this.root;
if (!current) return null;
queue.Push(current);
while (current = queue.shift()) {
result += current.value + ' ';
current.left && queue.Push(current.left);
current.right && queue.Push(current.right);
}
return result;
};
console.log('Breadth First: ', bst.breadthFirst());
//Breadth First: 20 8 22 4 12 24 10 14