Eu estou procurando um algoritmo de pesquisa de profundidade não recursiva em primeiro lugar para uma árvore não binária. Qualquer ajuda é muito apreciada.
Eu estou procurando um algoritmo de pesquisa de profundidade não recursiva em primeiro lugar para uma árvore não binária. Qualquer ajuda é muito apreciada.
Respostas:
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
}
A simetria dos dois é bem legal.
Atualização: como indicado, take_first()
remove e retorna o primeiro elemento da lista.
.first()
função também remove o elemento da lista. Como shift()
em muitas línguas. pop()
também funciona e retorna os nós filhos na ordem da direita para a esquerda, em vez de da esquerda para a direita.
gray(1st)->gray(2nd)->gray(3rd)->blacken(3rd)->blacken(2nd)->blacken(1st)
. Mas seu código produz: gray(1st)->gray(2nd)->gray(3rd)->blacken(2nd)->blacken(3rd)->blacken(1st)
.
Você usaria uma pilha que contém os nós que ainda não foram visitados:
stack.push(root)
while !stack.isEmpty() do
node = stack.pop()
for each node.childNodes do
stack.push(stack)
endfor
// …
endwhile
if (nodes are not marked)
para julgar se é apropriado ser empurrado para a pilha. Isso pode funcionar?
doing cycles
? Eu acho que só quero a ordem do DFS. Está certo ou não, obrigado.
for each node.childNodes.reverse() do stack.push(stack) endfor
). Provavelmente também é isso que você deseja. Boa explicação por que é assim é neste vídeo: youtube.com/watch?v=cZPXfl_tUkA endfor
Se você tiver ponteiros para nós pai, poderá fazê-lo sem memória adicional.
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
Observe que, se os nós filhos forem armazenados como uma matriz, e não através de ponteiros para irmãos, o próximo irmão poderá ser encontrado como:
def next_sibling(node):
try:
i = node.parent.child_nodes.index(node)
return node.parent.child_nodes[i+1]
except (IndexError, AttributeError):
return None
while not node.next_sibling or node is root:
.
Use uma pilha para rastrear seus nós
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)
}
Enquanto "usar uma pilha" pode funcionar como a resposta para uma pergunta artificial da entrevista, na realidade, é apenas fazer explicitamente o que um programa recursivo faz nos bastidores.
A recursão usa a pilha incorporada dos programas. Quando você chama uma função, ela envia os argumentos para a função para a pilha e, quando a função retorna, o faz poprando a pilha do programa.
Uma implementação do ES6 com base na grande resposta do biziclops:
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);
}
}
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);
}
}
A lógica geral é empurrar um nó (começando da raiz) no valor Stack, Pop () it e Print (). Então, se houver filhos (esquerdo e direito), empurre-os para a pilha - empurre para a direita primeiro, para visitar o filho esquerdo primeiro (depois de visitar o próprio nó). Quando a pilha estiver vazia (), você terá visitado todos os nós na Pré-encomenda.
DFS não recursivo usando geradores ES6
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
}
}
Ele se desvia do DFS não recursivo típico para detectar facilmente quando todos os descendentes alcançáveis de um determinado nó foram processados e para manter o caminho atual na lista / pilha.
Suponha que você queira executar uma notificação quando cada nó em um gráfico for visitado. A implementação recursiva simples é:
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
}
Ok, agora você quer uma implementação baseada em pilha porque seu exemplo não funciona. Gráficos complexos podem, por exemplo, causar uma explosão na pilha do seu programa e você precisa implementar uma versão não recursiva. O maior problema é saber quando emitir uma notificação.
O pseudocódigo a seguir funciona (combinação de Java e C ++ para facilitar a leitura):
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);
}
}
Parece complicado, mas a lógica extra necessária para emitir notificações existe porque você precisa notificar em ordem inversa da visita - o DFS inicia na raiz, mas a notifica por último, ao contrário do BFS, que é muito simples de implementar.
Para chutes, tente o seguinte gráfico: os nós são s, t, vew. arestas direcionadas são: s-> t, s-> v, t-> w, v-> we v-> t. Execute sua própria implementação do DFS e a ordem na qual os nós devem ser visitados deve ser: w, t, v, s Uma implementação desajeitada do DFS talvez notifique primeiro t e isso indica um erro. Uma implementação recursiva do DFS sempre alcançaria w last.
Exemplo de código de TRABALHO COMPLETO, sem pilha:
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);
}}
saída: Largura Primeiro Traversal - a partir do vértice 2: 2 0 3 1 4 Profundidade Primeiro Traversal - a partir do vértice 2: 2 3 4 1 0
Você pode usar uma pilha. Implementei gráficos com Adjacency Matrix:
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();
}
}
}
Iterativo DFS em Java:
//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;
}
http://www.youtube.com/watch?v=zLZhSSXAwxI
Acabei de assistir este vídeo e saiu com a implementação. Parece fácil para mim entender. Por favor, critique isso.
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()
}
Usando Stack
, aqui estão as etapas a seguir: Empurre o primeiro vértice da pilha e, em seguida,
Aqui está o programa Java seguindo as etapas acima:
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;
}
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);
}
}
Pseudo-código com base na resposta de @ biziclop:
getNode(id)
egetChildren(id)
N
Observação: eu uso a indexação de matriz de 1, não 0.
Largura primeiro
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
Profundidade primeiro
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
Aqui está um link para um programa java que mostra o DFS seguindo métodos reccursivos e não reccursivos e também calculando o tempo de descoberta e de término , mas sem identificação de borda.
public void DFSIterative() {
Reset();
Stack<Vertex> s = new Stack<>();
for (Vertex v : vertices.values()) {
if (!v.visited) {
v.d = ++time;
v.visited = true;
s.push(v);
while (!s.isEmpty()) {
Vertex u = s.peek();
s.pop();
boolean bFinished = true;
for (Vertex w : u.adj) {
if (!w.visited) {
w.visited = true;
w.d = ++time;
w.p = u;
s.push(w);
bFinished = false;
break;
}
}
if (bFinished) {
u.f = ++time;
if (u.p != null)
s.push(u.p);
}
}
}
}
}
Fonte completa aqui .
Só queria adicionar minha implementação python à longa lista de soluções. Esse algoritmo não recursivo possui descoberta e eventos finalizados.
worklist = [root_node]
visited = set()
while worklist:
node = worklist[-1]
if node in visited:
# Node is finished
worklist.pop()
else:
# Node is discovered
visited.add(node)
for child in node.children:
worklist.append(child)