|
| 1 | +# Breadth First Search |
| 2 | + |
| 3 | +A **Busca em largura** ou do inglês _breadth First Search_ é um algoritmo bastante utilizado para realizar buscas em estruturas de Grafos. Ela é bem parecida com a busca em profundidade(DFS), sendo sua principal diferença a forma como expandimos a busca pelos nós vizinhos em relação ao nó inicial. |
| 4 | + |
| 5 | +Essa expansão ocorre em forma a analoga a uma teia de aranha, em que é visitado primeiro todos os vizinhos do vérice inicial para após isso expandir para os outros vértices(vizinhos dos vizinho). |
| 6 | + |
| 7 | + |
| 8 | + |
| 9 | +Fonte do GIF: [Medium](https://medium.com/@anwarhermuche/m%C3%A9todos-de-busca-em-grafos-bfs-dfs-cf17761a0dd9) |
| 10 | + |
| 11 | +## Como funciona |
| 12 | + |
| 13 | +A busca em largura é implementada geralmente na forma interativa e funciona da seguinte maneira: |
| 14 | + |
| 15 | + 1. É escolhido um vértice inicial para começar a expansão do grafo, e depedendo do probelma a ser resolvido, também é passado um vértice alvo para a busca. |
| 16 | + |
| 17 | + 2. É iniciado uma estrutura de fila com o vértice inicial sendo o seu primeiro elemento. |
| 18 | + |
| 19 | + 3. Após a inicialização da fila, é feito a remoção do vértice e se este vértice ainda não foi visitado, ele é marcado como visitado e é obtido uma lista de seus vértices vizinhos. |
| 20 | + |
| 21 | + 4. É feito uma iteração na lista de vizinhos e é feito uma checagem para cada vizinho, se este vizinho ainda não foi visitado, ele é adicionado a fila para ser visitado. |
| 22 | + |
| 23 | + 5. É feito a repetição dos passos 3 e 4 até que todos os vértices do grafo sejam visitados. |
| 24 | + |
| 25 | +## Código de exemplo |
| 26 | +O código a seguir implementa a busca em profundidade tanto recursivamente como iterativamente |
| 27 | +```javascript |
| 28 | +function BFS(adjMatrix, visited, startVertex) { |
| 29 | + const queue = [startVertex]; |
| 30 | + |
| 31 | + if (startVertex >= adjMatrix.length) { |
| 32 | + console.log("The Adjency Matrix don't contain that start vertex"); |
| 33 | + return -1; |
| 34 | + } |
| 35 | + |
| 36 | + while (queue.length > 0) { |
| 37 | + let v = queue.shift(); |
| 38 | + |
| 39 | + if (!visited[v]) { |
| 40 | + visited[v] = true; |
| 41 | + |
| 42 | + const neighboors = adjMatrix[v]; |
| 43 | + |
| 44 | + console.log(`the vertex ${v + 1} is being visited`); |
| 45 | + |
| 46 | + for (let neighboor of neighboors) { |
| 47 | + if (!visited[neighboor]) { |
| 48 | + queue.push(neighboor); |
| 49 | + } |
| 50 | + } |
| 51 | + } |
| 52 | + } |
| 53 | + console.log('All vertex were visited'); |
| 54 | +} |
| 55 | + |
| 56 | +function fillVisitedArray(booleanArray, length) { |
| 57 | + for (let idx = 0; idx < length; idx++) { |
| 58 | + booleanArray.push(false); |
| 59 | + } |
| 60 | + |
| 61 | + return booleanArray; |
| 62 | +} |
| 63 | + |
| 64 | +const adjMatrix = [[1, 4, 2], [5, 3], [3, 6], [1, 2, 4], [0, 3], [1], [2]]; |
| 65 | + |
| 66 | +const visited = fillVisitedArray([], adjMatrix.length); |
| 67 | + |
| 68 | +BFS(adjMatrix, visited, 0); |
| 69 | + |
| 70 | +``` |
| 71 | + |
| 72 | +## Explicação do código |
| 73 | + |
| 74 | +* __Matriz de adjacência__: A matriz ```adjMatrix``` representa o Grafo e suas conexões, sendo cada linha da matriz um vértice de 0 á 6 e cada coluna, os vizinhos que compõem as arestas de cada vértice. |
| 75 | + |
| 76 | + |
| 77 | +* __Função__: A Função **DFS** recebe 3 paramêtros: |
| 78 | + |
| 79 | +- ```adjMatrix```: A matriz de adjacência que representa um Grado G qualquer. |
| 80 | +- ```visited```: uma lista de vértices visitados |
| 81 | +- ```startVertex```: O vértice que será realizada a expansão da DFS. |
| 82 | + |
| 83 | +O algorimto irá visitar todos os vérices do grafo, porém so irá expandir a busca para aqueles que ainda não foram visitados, dando prioridade para os vizinhos do vértice atual. |
| 84 | + |
| 85 | +* __Saída__: A saída padrão para este código é a descoberta de todos vértices do grafo, conforme a seguinte exemplo de saída do console: |
| 86 | + |
| 87 | +``` |
| 88 | +the vertex 0 is being visited |
| 89 | +the vertex 1 is being visited |
| 90 | +the vertex 4 is being visited |
| 91 | +the vertex 2 is being visited |
| 92 | +the vertex 5 is being visited |
| 93 | +the vertex 3 is being visited |
| 94 | +the vertex 6 is being visited |
| 95 | + |
| 96 | +All vertex were visited |
| 97 | + |
| 98 | +```` |
| 99 | + |
| 100 | +## Complexidade de tempo: |
| 101 | + |
| 102 | +A complexidade de tempo da busca em profundidade é __O(V+E)__, onde __V__ , ou seja ela tem um complexidade de tempo linear em função di total de vértices e o total de arestas do grafo. |
| 103 | + |
| 104 | +## Quando usar busca por profundidade? |
| 105 | + |
| 106 | +* Em problemas pode ser modelado em encontrar o menor caminho de um grafo não ponderado. |
| 107 | + |
| 108 | +* Em problemas de exploração de grafos ou redes. |
| 109 | + |
| 110 | +* Achar uma árvore geradora minima(MST) e problemas de busca em labirintos. |
0 commit comments