BFS的应用求最短路径

  因为在leetcode的卡片上学习队列，才发现，都是BFS应用的题目，队列只是个“辅助”，BFS才是“打野”。好吧，那就先解决BFS。什么是BFS？全称：Breadth First Search，是一种图形搜索算法。简单的说，BFS是从根节点开始，沿着树的宽度遍历树的节点。如果所有节点均被访问，则算法中止。（https://zh.wikipedia.org/wiki/广度优先搜索）


明白了，说到BFS就要先建立图，进而在图的基础上讲BFS。

1，图的设计与实现

1）什么是图？

概念就直接google吧，但需要了解和掌握这三个概念：图的基本常识（有向图，无向图，带权等），两种存储结构（二维数组，邻接表），连通图和生产树。

图 1 邻接表存储有向图

图 2 有向图对应的二维数组 2，图的编程实现（Java，邻接表存储）

// Java code to demonstrate Graph representation 
// using ArrayList in Java 
import java.util.*; 
  
class Graph { 
    ArrayList > adj; 
    int V; 
    Graph(int v) 
    { 
        V = v; 
        adj = new ArrayList >(V); 
        for (int i = 0; i < V; i++) 
            adj.add(new ArrayList()); 
    } 
  
    void addEdge(int u, int v) 
    { 
        adj.get(u).add(v); 
        adj.get(v).add(u); 
    } 
  
    void printAdjacencyList() 
    { 
        for (int i = 0; i < adj.size(); i++) { 
            System.out.println("Adjacency list of " + i); 
            for (int j = 0; j < adj.get(i).size(); j++) { 
                System.out.print(adj.get(i).get(j) + " "); 
            } 
            System.out.println(); 
        } 
    } 
} 
  
class Test { 
  
    public static void main(String[] args) 
    { 
        // Creating a graph with 5 vertices 
        int V = 5; 
  
        Graph g = new Graph(V); 
  
        // Adding edges one by one. 
        g.addEdge(0, 1); 
        g.addEdge(0, 4); 
        g.addEdge(1, 2); 
        g.addEdge(1, 3); 
        g.addEdge(1, 4); 
        g.addEdge(2, 3); 
        g.addEdge(3, 4); 
        g.printAdjacencyList(); 
    } 
    }

3,，图的BFS（Java）

// prints BFS traversal from a given source s
void BFS(int s) {
		// Mark all the vertices as not visited(By default
		// set as false)
		boolean visited[] = new boolean[V];

		// Create a queue for BFS
		LinkedList queue = new LinkedList();

		// Mark the current node as visited and enqueue it
		visited[s] = true;
		queue.add(s);

		while (queue.size() != 0) {
			// Dequeue a vertex from queue and print it
			s = queue.poll();
			System.out.print(s + " ");

			// Get all adjacent vertices of the dequeued vertex s
			// If a adjacent has not been visited, then mark it
			// visited and enqueue it
			Iterator i = adj[s].listIterator();
			while (i.hasNext()) {
				int n = i.next();
				if (!visited[n]) {
					visited[n] = true;
					queue.add(n);
				}
			}
		}
	}

4，感悟与思考

图是算法里面常考的，非常重要。BFS算法中，队列的作用：存放 与 所选路径形成的图（染黑的节点） 连接的节点。涉及到了归纳法，从一个节点递归到所有。