《算法》第四章部分程序 part 5

▶ 书中第四章部分程序，加上自己补充的代码，图的深度优先遍历

● 无向图的广度优先遍历，有向 / 无向图代码仅若干方法名不同

 package package01;

 import edu.princeton.cs.algs4.In;
 import edu.princeton.cs.algs4.StdOut;
 import edu.princeton.cs.algs4.Graph;
 import edu.princeton.cs.algs4.Stack;
 import edu.princeton.cs.algs4.Queue;

 public class class01
 {
     private static final int INFINITY = Integer.MAX_VALUE;
     private boolean[] marked;       // 顶点是否已被遍历
     private int[] edgeTo;           // 每个顶点在 s - v 路径中的父顶点
     private int[] distTo;           // 每个顶点在 s - v 路径中的路径长

     public class01(Graph G, int s)
     {
         marked = new boolean[G.V()];
         distTo = new int[G.V()];
         edgeTo = new int[G.V()];
         for (int v = 0; v < G.V(); v++)
             distTo[v] = INFINITY;
         nonRecursiveBFS(G, s);
         //assert check(G, s);
     }

     private void nonRecursiveBFS(Graph G, int s)
     {
         Queue<Integer> q = new Queue<Integer>();
         distTo[s] = 0;
         marked[s] = true;
         for (q.enqueue(s); !q.isEmpty();)
         {
             int v = q.dequeue();
             for (int w : G.adj(v))
             {
                 if (!marked[w])
                 {
                     edgeTo[w] = v;
                     distTo[w] = distTo[v] + 1;
                     marked[w] = true;
                     q.enqueue(w);
                 }
             }
         }
     }

     private void nonRecursiveBFS(Graph G, Iterable<Integer> sources) // 以迭代器元素为起点列表进行遍历
     {
         Queue<Integer> q = new Queue<Integer>();
         for (int s : sources)
         {
             marked[s] = true;
             distTo[s] = 0;
             q.enqueue(s);
         }
         for (;!q.isEmpty();)
         {
             int v = q.dequeue();
             for (int w : G.adj(v))
             {
                 if (!marked[w])
                 {
                     edgeTo[w] = v;
                     distTo[w] = distTo[v] + 1;
                     marked[w] = true;
                     q.enqueue(w);
                 }
             }
         }
     }

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

     public int distTo(int v)
     {
         return distTo[v];
     }

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

     private boolean check(Graph G, int s)
     {
         if (distTo[s] != 0)
         {
             StdOut.println("\n<check> error distance of s.\n");
             return false;
         }
         for (int v = 0; v < G.V(); v++)
         {
             for (int w : G.adj(v))
             {
                 if (marked(v) != marked(w))                     // 检查边正确性
                 {
                     StdOut.println("edge " + v + "-" + w);
                     StdOut.println("marked(" + v + ") = " + marked(v));
                     StdOut.println("marked(" + w + ") = " + marked(w));
                     return false;
                 }
                 if (marked(v) && (distTo[w] > distTo[v] + 1))   // 检查顶点 v 相连的顶点的距离正确性
                 {
                     StdOut.println("edge " + v + "-" + w);
                     StdOut.println("distTo[" + v + "] = " + distTo[v]);
                     StdOut.println("distTo[" + w + "] = " + distTo[w]);
                     return false;
                 }
             }
         }
         for (int w = 0; w < G.V(); w++)
         {
             if (!marked(w) || w == s)
                 continue;
             int v = edgeTo[w];
             if (distTo[w] != distTo[v] + 1)                     // 逐边检查距离正确性
             {
                 StdOut.println("shortest path edge " + v + "-" + w);
                 StdOut.println("distTo[" + v + "] = " + distTo[v]);
                 StdOut.println("distTo[" + w + "] = " + distTo[w]);
                 return false;
             }
         }
         return true;
     }

     public static void main(String[] args)
     {
         In in = new In(args[0]);
         int s = Integer.parseInt(args[1]);
         Graph G = new Graph(in);
         class01 search = new class01(G, s);
         for (int v = 0; v < G.V(); v++)
         {
             if (search.marked(v))
             {
                 StdOut.printf("%d to %d (%d):  ", s, v, search.distTo(v));
                 for (int x : search.pathTo(v))
                 {
                     if (x == s)
                         StdOut.print(x);
                     else
                         StdOut.print("-" + x);
                 }
                 StdOut.println();
             }
             else
                 StdOut.printf("%d to %d (-): not connected\n", s, v);
         }
     }
 }

● 有向图广度优先遍历

 package package01;

 import edu.princeton.cs.algs4.In;
 import edu.princeton.cs.algs4.StdOut;
 import edu.princeton.cs.algs4.Digraph;
 import edu.princeton.cs.algs4.Stack;
 import edu.princeton.cs.algs4.Queue;

 public class class01
 {
     private static final int INFINITY = Integer.MAX_VALUE;
     private boolean[] marked;
     private int[] edgeTo;
     private int[] distTo;      

     public class01(Digraph G, int s)
     {
         marked = new boolean[G.V()];
         distTo = new int[G.V()];
         edgeTo = new int[G.V()];
         for (int v = 0; v < G.V(); v++)
             distTo[v] = INFINITY;
         nonRecursiveBFS(G, s);
     }

     private void nonRecursiveBFS(Digraph G, int s)
     {
         Queue<Integer> q = new Queue<Integer>();
         distTo[s] = 0;
         marked[s] = true;
         for (q.enqueue(s); !q.isEmpty();)
         {
             int v = q.dequeue();
             for (int w : G.adj(v))
             {
                 if (!marked[w])
                 {
                     edgeTo[w] = v;
                     distTo[w] = distTo[v] + 1;
                     marked[w] = true;
                     q.enqueue(w);
                 }
             }
         }
     }

     private void nonRecursiveBFS(Digraph G, Iterable<Integer> sources)
     {
         Queue<Integer> q = new Queue<Integer>();
         for (int s : sources)
         {
             marked[s] = true;
             distTo[s] = 0;
             q.enqueue(s);
         }
         for (;!q.isEmpty();)
         {
             int v = q.dequeue();
             for (int w : G.adj(v))
             {
                 if (!marked[w])
                 {
                     edgeTo[w] = v;
                     distTo[w] = distTo[v] + 1;
                     marked[w] = true;
                     q.enqueue(w);
                 }
             }
         }
     }

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

     public int distTo(int v)
     {
         return distTo[v];
     }

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

     public static void main(String[] args)
     {
         In in = new In(args[0]);
         int s = Integer.parseInt(args[1]);
         Digraph G = new Digraph(in);
         class01 search = new class01(G, s);
         for (int v = 0; v < G.V(); v++)
         {
             if (search.marked(v))
             {
                 StdOut.printf("%d to %d (%d):  ", s, v, search.distTo(v));
                 for (int x : search.pathTo(v))
                 {
                     if (x == s)
                         StdOut.print(x);
                     else
                         StdOut.print("->" + x);
                 }
                 StdOut.println();
             }
             else
                 StdOut.printf("%d to %d (-):  not connected\n", s, v);
         }
     }
 }