演算法是基礎，小藍同學準備些總結一系列演算法分享給大家，這是第10篇《無向圖搜尋》，非常贊！希望對大家有幫助，大家會喜歡！

前面系列文章：   

歸併排序

二分查詢

二叉樹查詢

  隨著圖資料庫，圖計算，知識圖譜的興起，圖這種資料結構使用逐漸面向大眾，更為的廣泛的使用我們這個篇章會給大家介紹圖的一些資料結構及其對應相關的一些演算法，希望大家能夠喜歡，並對大家理解知識圖譜，圖計算有所幫助

   本篇從無向圖搜尋講起，說起無向圖搜尋 主要分為兩塊一塊時深度優先，一塊是廣度優先。其實圖搜尋可以我在電腦裡有一個資料夾，這個資料夾裡有很多細分資料夾，而我們要便利每一個資料夾的一個過程。

而深度優先指的是，我先開啟最開始的那個資料夾，之後再開啟他下面的第一個資料夾，之後再開啟這個子檔案的子資料夾，迴圈往復的一個過程 ，直到所有的資料夾裡的檔案都便利過一遍。同理廣度優先是指我先開啟這個資料夾裡的所有檔案，然後再逐個開啟他子檔案的所有檔案的一個迴圈往復的一個過程。

二話不說上程式碼吧 哈哈

深度優先搜尋程式碼

public class DepthFirstPaths {
private boolean[] marked;
   private int[] edgeTo;
   private final int s;
   public DepthFirstPaths(Graph G, int s) {
      marked = new boolean[G.V()];
edgeTo = new int[G.V()];
      this.s = s;
dfs(G, s);
}

private void dfs(Graph G, int v) {
      marked[v] = true;
 
      for (int w : G.adj(v)) {
if (!marked[w]) {
            edgeTo[w] = v;
dfs(G, w);
}
      }
   }

public boolean hasPathTo(int v) {
return marked[v];
}

public Iterable<Integer> pathTo(int v) {
if (!hasPathTo(v)) {
return null;
}
      Stack<Integer> path = new Stack<Integer>();
      for (int 
 
x = v; x != s; x = edgeTo[x]) {
         path.push(x);
}
      path.push(s);
      return path;
}

public static void main(String[] args) {
      Graph G = new Graph(new In(args[0]));
      int s = Integer.parseInt(args[1]);
DepthFirstPaths search = new DepthFirstPaths(G, s);
      for (int v = 0; v < G.V(); v++) {
         StdOut.print(s + " to " + v + ": ");
         if (search.hasPathTo(v)) {
for (int x : search.pathTo(v)) {
if (x == s) {
                  StdOut.print(x);
} else {
                  StdOut.print("-" + x);
}
            }
         }
         StdOut.println();
}
   }

廣度優先搜尋程式碼

public class BreadthFirstPaths {
private boolean[] marked;
   private int[] edgeTo;
   private int[] distTo; // Add for Exercise 4.1.13
private final int s;
   public BreadthFirstPaths(Graph G, int s) {
      marked = new boolean[G.V()];
edgeTo = new int[G.V()];
distTo = new int[G.V()]; // Add for Exercise 4.1.13
this.s = s;
bfs(G, s);
}

private void bfs(Graph G, int s) {
      Queue<Integer> queue = new Queue<Integer>();
marked[s] = true;
// Add for Exercise 4.1.13
for (int v = 0; v < G.V(); v++) {
         distTo[v] = Integer.MAX_VALUE;
}
      distTo[s] = 0;
queue.enqueue(s);
      while (!queue.isEmpty()) {
int v = queue.dequeue();
         for (int w : G.adj(v)) {
if (!marked[w]) {
               edgeTo[w] = v;
marked[w] = true;
distTo[w] = distTo[v] + 1; // Add for Exercise 4.1.13
queue.enqueue(w);
}
         }
      }
   }

public boolean hasPathTo(int v) {
return marked[v];
}

public Iterable<Integer> pathTo(int v) {
if (!hasPathTo(v)) {
return null;
}
      Stack<Integer> path = new Stack<Integer>();
      for (int x = v; x != s; x = edgeTo[x]) {
         path.push(x);
}
      path.push(s);
      return path;
}

/**
    * Exercise 4.1.13
    * 
    * @param v
    * @return
*/
public int distTo(int v) {
return distTo[v];
}

public static void main(String[] args) {
      Graph G = new Graph(new In(args[0]));
      int s = Integer.parseInt(args[1]);
BreadthFirstPaths search = new BreadthFirstPaths(G, s);
      for (int v = 0; v < G.V(); v++) {
         StdOut.print(s + " to " + v + ": ");
         if (search.hasPathTo(v)) {
for (int x : search.pathTo(v)) {
if (x == s) {
                  StdOut.print(x);
} else {
                  StdOut.print("-" + x);
}
            }
         }
         StdOut.println();
}
   }
}

應用再知識圖譜中風控大量的應用了無向圖搜尋的內容，有興趣的同學可以自己去找找相關資料。

猜你喜歡

大資料和雲端計算技術週報（第56期）

加入技術討論群

《大資料和雲端計算技術》社群群人數已經3000+，歡迎大家加下面助手微信，拉大家進群，自由交流。

喜歡QQ群的，可以掃描下面二維碼：

歡迎大家通過二維碼打賞支援技術社群（英雄請留名，社群感謝您，打賞次數超過108+）：