Figura - profundidad-primero algoritmo de búsqueda (DFS)

Primero en amplitud algoritmo de búsqueda es una prioridad "manta" algoritmos de búsqueda de todos los niveles para promover, en primer lugar localizar el más cercano al vértice de inicio, a continuación, la siguiente más cercana, gire a cabo la búsqueda.

El algoritmo de búsqueda en profundidad como "laberinto" es un "no golpear la pared de ladrillo no mira hacia atrás," el algoritmo de búsqueda

Supongamos que un tenedor en la carretera había un laberinto, y luego quiere encontrar la salida.

Elegidos al azar a un tenedor en el camino, se acercó al descubierto un callejón sin salida, se puede recurrir a un tenedor en la carretera, volver a seleccionar una manera de seguir adelante hasta que, finalmente, encontrar la salida.

 

Esta caída posterior al último tenedor en la carretera, de hecho, pensando, pensando proceso de resolución de problemas en la espalda, ideal para usar recursividad para lograr.

 

la implementación del código

 

premisa

código de configuración figura se implementa utilizando una lista de vecinos impotente a la figura.

 

Es decir, las variables pueden hacer referencia a blog anterior algoritmo primero en amplitud

 

import java.util.LinkedList;

public class Graph {  //无向图

    private int v; // 顶点的个数
    private LinkedList<Integer> adj[]; // 邻接表

    public Graph(int v) {
        this.v = v;
        adj = new LinkedList[v];
        for (int i = 0; i < v; ++i) {
            adj[i] = new LinkedList<>();
        }
    }

    public void addEdge(int s, int t) { // 无向图一条边存两次
        adj[s].add(t);
        adj[t].add(s);
    }

    private void print(int[] prev, int s, int t) { // 因为搜索路径是反向存储，递归打印s->t的路径
        if (prev[t] != -1 && t != s) {
            print(prev, s, prev[t]);
        }
        System.out.print(t + " ");
    }


    boolean found = false; // 全局变量，当已经找到目标顶点时，就不再递归查找

    public void dfs(int s, int t) {
        found = false;
        boolean[] visited = new boolean[v];
        int[] prev = new int[v];
        for (int i = 0; i < v; ++i) {
            prev[i] = -1;
        }
        recurDfs(s, t, visited, prev);
        print(prev, s, t);
    }

    private void recurDfs(int w, int t, boolean[] visited, int[] prev) {
        if (found == true) return;
        visited[w] = true;
        if (w == t) {
            found = true;
            return;
        }
        for (int i = 0; i < adj[w].size(); ++i) {
            int q = adj[w].get(i);
            if (!visited[q]) {
                prev[q] = w;
                recurDfs(q, t, visited, prev);
            }
        }
    }

    public static void main(String[] args) {
        Graph graph = new Graph(8);
        graph.addEdge(0, 1);
        graph.addEdge(0, 3);
        graph.addEdge(1, 2);
        graph.addEdge(1, 4);
        graph.addEdge(3, 4);
        graph.addEdge(2, 5);
        graph.addEdge(4, 5);
        graph.addEdge(4, 6);
        graph.addEdge(5, 7);
        graph.addEdge(6, 7);

        graph.dfs(0,7);

    }
}