Вы находитесь на странице: 1из 7

Определение BFS:

Поиск в ширину (BFS) - это метод обхода, используемый в графах.


Использует очередь для хранения посещенных вершин. В этом
методе акцент делается на вершинах графа, сначала выбирается
одна вершина, затем ее посещают и отмечают. Вершины, смежные
с посещенной вершиной, затем посещаются и сохраняются в
очереди последовательно.

Точно так же сохраненные вершины затем обрабатываются одна за


другой, и их соседние вершины посещаются. Узел полностью
исследуется перед посещением любого другого узла в графе,
другими словами, он сначала пересекает самые мелкие
неисследованные узлы.

Пример:
У нас есть граф с вершинами A, B, C, D, E, F, G. Рассматривая A в
качестве отправной точки. Шаги, вовлеченные в процесс:

1. Вершина А раскрывается и сохраняется в очереди.


2. Вершины B, D и G наследники A расширяются и сохраняются в
очереди, а вершина A удаляется.
3. Теперь B в переднем конце очереди удаляется вместе с
сохранением его последующих вершин E и F.
4. Вершина D на переднем конце очереди удаляется, а ее
связанный узел F уже посещен.
5. Вершина G удалена из очереди, и у нее есть преемник E,
который уже посещен.
6. Теперь E и F удаляются из очереди, а его последующая
вершина C проходит и сохраняется в очереди.
7. Наконец C также удаляется, и очередь пуста, что означает, что
мы закончили.
8. Сгенерированный выход - A, B, D, G, E, F, C.
9. BFS пример приложения
10. BFS может быть полезен для определения, имеет ли граф
связанные компоненты или нет. А также он может быть
использован при обнаружении двудольного графа.

Граф является двудольным, когда вершины графа разделены на


два непересекающихся множества; никакие две соседние вершины
не будут находиться в одном наборе. Другой метод проверки
двудольного графа состоит в проверке появления нечетного цикла
в графе. Двудольный граф не должен содержать нечетного цикла.

BFS также лучше находит кратчайший путь в графе, который можно


рассматривать как сеть.
Определение ДФС
Метод обхода в глубину поиска (DFS) использует стек для хранения
посещенных вершин. DFS является методом, основанным на ребре,
и работает рекурсивно, когда вершины исследуются вдоль пути
(ребра). Исследование узла приостанавливается, как только
обнаруживается другой неисследованный узел, и самые глубокие
неисследованные узлы пересекаются в первую очередь. DFS
проходит / посещает каждую вершину ровно один раз, и каждое
ребро проверяется ровно дважды.

Пример:
Подобно BFS, давайте возьмем те же шаги для выполнения
операций DFS:
1. Рассматривая A как начальную вершину, которая исследуется
и сохраняется в стеке.
2. Последующая вершина B хранится в стеке.
3. У вершины B есть два преемника E и F, среди которых в
алфавитном порядке E исследуется первым и сохраняется в
стеке.
4. Преемник вершины E, то есть G, хранится в стеке.
5. У вершины G есть две соединенные вершины, и обе уже
посещены, поэтому G выталкивается из стека.
6. Точно так же E s также удалены.
7. Теперь вершина B находится на вершине стека, ее другой узел
(вершина) F исследуется и сохраняется в стеке.
8. У вершины F есть два преемника C и D, между которыми
сначала обходится C и сохраняется в стеке.
9. У вершины C есть только один предшественник, который уже
посещен, поэтому он удаляется из стека.
10. Теперь вершина D, соединенная с F, посещается и
сохраняется в стеке.
11. Поскольку вершина D не имеет никаких не посещенных
узлов, следовательно, D удаляется.
12. Точно так же F, B и A также появляются.
13. Сгенерированный выход - A, B, E, G, F, C, D.

Оценка сложности:

Временная сложность как BFS, так и DFS


будет O (V + E), где V - количество
вершин, а E - число ребер. Это зависит от
структуры данных, которую мы
используем для представления графа.
Если это смежная матрица, это будет O
(V ^ 2). Если мы используем смежный
список, это будет O (V + E).
Ключевые различия между BFS и DFS
 BFS - это алгоритм на основе вершин, а DFS - алгоритм на
основе ребер.
 Структура данных очереди используется в BFS. С другой
стороны, DFS использует стек или рекурсию.
 Пространство памяти эффективно используется в DFS, а
использование пространства в BFS неэффективно.
 BFS - оптимальный алгоритм, а DFS - не оптимальный.
 DFS строит узкие и длинные деревья. В отличие от BFS строит
широкое и короткое дерево.
Имплементация:

public void dfs() {


//DFS uses Stack data structure
Stack s = new Stack();
s.push(this.rootNode);
rootNode.visited = true;
printNode(rootNode);
while(!s.isEmpty()) {
Node n = (Node)s.peek();
Node child = getUnvisitedChildNode(n); // Essentially this
function goes through the neighbors of n, and finds the one with
node.visited = false
if(child != null) {
child.visited = true;
printNode(child); // print the node as you like.
s.push(child);
}
else {
s.pop();
}
}
//Clear visited property of nodes
clearNodes();
}

public void bfs() {


//BFS uses Queue data structure
Queue q = new LinkedList();
q.add(this.rootNode);
printNode(this.rootNode);
rootNode.visited = true;
while(!q.isEmpty()) {
Node n = (Node)q.remove();
Node child = null;
while((child = getUnvisitedChildNode(n)) != null) {
child.visited = true;
printNode(child);
q.add(child);
}
}
//Clear visited property of nodes
clearNodes();
}

Вывод:
BFS и DFS, оба метода поиска графа имеют одинаковое время
выполнения, но разное потребление пространства, DFS занимает
линейное пространство, потому что мы должны помнить один путь
с неизведанными узлами, в то время как BFS хранит каждый узел в
памяти.

DFS дает более глубокие решения и не является оптимальным, но


он хорошо работает, когда решение неизвестно, тогда как BFS
является оптимальным, который сначала ищет оптимальную цель.