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

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

● 无向图的深度优先遍历，有向 / 无向图代码仅若干方法名不同，包括递归和非递归版本，去掉了顶点有效性的检查

 package package01;

 import java.util.Iterator;              // nonRecursiveDFS 需要
 import edu.princeton.cs.algs4.In;
 import edu.princeton.cs.algs4.StdOut;
 import edu.princeton.cs.algs4.Graph;
 import edu.princeton.cs.algs4.Stack;    // recursiveDFS 不用

 public class class01
 {
     private final int s;                // 根顶点，depthFirstPath 需要
     private boolean[] marked;           // 顶点是否已被遍历
     private int count;                  // 已遍历的顶点数（含后退），即从 s 可达的顶点数，depthFirstPath 不用
     private int[] edgeTo;               // 每个顶点在 s - v 路径中的父顶点，depthFirstPath 需要

     public class01(Graph G, int inputS) // 初始化，开始DFS
     {
         s = inputS;
         marked = new boolean[G.V()];
         edgeTo = new int[G.V()];
         recursiveDFS(G, s);
     }

     private void recursiveDFS(Graph G, int v)
     {
         count++;
         marked[v] = true;
         for (int w : G.adj(v))
         {
             if (!marked[w])
             {
                 edgeTo[w] = v;          //  depthFirstPath 需要
                 recursiveDFS(G, w);
             }
         }
     }

     public void nonRecursiveDFS(Graph G, int s)     // 非递归版本
     {
         marked = new boolean[G.V()];
         Iterator<Integer>[] adj = (Iterator<Integer>[]) new Iterator[G.V()];// 记录每个顶点处已经遍历到了哪一个链表节点
         for (int v = 0; v < G.V(); v++)
             adj[v] = G.adj(v).iterator();
         Stack<Integer> stack = new Stack<Integer>();
         marked[s] = true;
         for (stack.push(s); !stack.isEmpty();)
         {
             int v = stack.peek();
             if (adj[v].hasNext())
             {
                 int w = adj[v].next();
                 if (!marked[w])
                 {
                     marked[w] = true;
                     stack.push(w);
                 }
             }
             else
                 stack.pop();
         }
     }

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

     public int count()
     {
         return count;
     }

     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)
     {
         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:  ", s, 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);
         }
         if (search.count() != G.V())
             StdOut.println("\nNot connected.\n");
         else
             StdOut.println("\nConnected.\n");
     }
 }

● 有向图的深度优先遍历

 package package01;

 import java.util.Iterator;
 import edu.princeton.cs.algs4.In;
 import edu.princeton.cs.algs4.StdOut;
 import edu.princeton.cs.algs4.Digraph;
 import edu.princeton.cs.algs4.Stack;

 public class class01
 {
     private final int s;
     private boolean[] marked;
     private int count;
     private int[] edgeTo;               

     public class01(Digraph G, int inputS)
     {
         s = inputS;
         marked = new boolean[G.V()];
         edgeTo = new int[G.V()];
         recursiveDirectedDFS(G, s);
     }

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

     public void nonRecursiveDirectedDFS(Digraph G, int s)
     {
         marked = new boolean[G.V()];
         Iterator<Integer>[] adj = (Iterator<Integer>[]) new Iterator[G.V()];
         for (int v = 0; v < G.V(); v++)
             adj[v] = G.adj(v).iterator();
         Stack<Integer> stack = new Stack<Integer>();
         marked[s] = true;
         for (stack.push(s); !stack.isEmpty();)
         {
             int v = stack.peek();
             if (adj[v].hasNext())
             {
                 int w = adj[v].next();
                 if (!marked[w])
                 {
                     marked[w] = true;
                     stack.push(w);
                 }
             }
             else
                 stack.pop();
         }
     }

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

     public int count()
     {
         return count;
     }

     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)
     {
         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:  ", s, 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);
         }
         if (search.count() != G.V())
             StdOut.println("\nNot connected.\n");
         else
             StdOut.println("\nConnected.\n");
     }
 }