算法导论-图的算法BFS宽度优先、DFS深度优先,topologicalSort拓扑排序,strongConnectedComponents强连通分支-Java实现

package graph;

import java.util.concurrent.ArrayBlockingQueue;

enum GraphColor {
 WHITE, GRAY, BLACK
}

class Vertice {
 public int index;
 public GraphColor color;
 public int d;
 public int p;
 public int f;

 public Vertice(int index, GraphColor color, int d, int p) {
  this.index = index;
  this.color = color;
  this.d = d;
  this.p = p;
 }
}

class ListItem {
 public Vertice This;
 public ListItem Next;

 public ListItem(Vertice This, ListItem Next) {
  this.This = This;
  this.Next = Next;
 }
}

public class Search {
 public static int time;
 public static Vertice[] V;
 public static ListItem[] G;
 public static void main(String args[]) {
  V = new Vertice[9];
  for (int i = 0; i < V.length; i++) {
   V[i] = new Vertice(i, GraphColor.WHITE, 1000, -1);
  }
  G = new ListItem[9];
  ListItem temp;
  
  G[0]=new ListItem(V[2],new ListItem(V[3],null));
  G[1]=new ListItem(V[3],null);
  G[2]=new ListItem(V[3],new ListItem(V[4],null));
  G[3]=null;
  G[3]=new ListItem(V[0],null);
  G[4]=new ListItem(V[7],null);
  G[5]=new ListItem(V[4],new ListItem(V[6],null));
  G[6]=new ListItem(V[7],null);
  G[7]=null;
  G[8]=null;
  
  print(G);

//  BFS(G, V, 0);

//  DFS(G, V);
  
//  topologicalSort(G,V);
  
  stronglyConnectedComponents(G,V);

//  print(V);

//  printPath(V, 1, 4);
 }

 private static void stronglyConnectedComponents(ListItem[] G, Vertice[] V) {
  DFS(G,V);
  ListItem[] GT=new ListItem[G.length];
  ListItem temp;
  for(int i=0;i<G.length;i++){
   temp=G[i];
   while(temp!=null){
    GT[temp.This.index]=new ListItem(V[i],GT[temp.This.index]);
    temp=temp.Next;
   }
  }
  print(GT);
  for(int i=0;i<V.length;i++){
   V[i].color=GraphColor.WHITE;
  }
  DFSFDECREASE(GT,V);
 }

 private static void DFSFDECREASE(ListItem[] GT, Vertice[] V) {
  time=0;
//  System.out.println(V[3].color);
  int[] flag=new int[V.length];
  for(int i=0;i<flag.length;i++){
   flag[i]=-1;
  }
  int[] list=new int[V.length*2+1];
  for(int i=0;i<list.length;i++){
   list[i]=-1;
  }
  for(int i=0;i<V.length;i++){
   list[V[i].f]=i;
  }
  int temp;
  int index=0;
  for(int i=0;i<list.length;i++){
   if(list[i]!=-1){
    temp=list[i];
    list[i]=list[index];
    list[index]=temp;
    index++;
   }
  }
  for(int i=0;i<V.length/2;i++){
   temp=list[i];
   list[i]=list[V.length-i-1];
   list[V.length-1-i]=temp;
  }
//  for(int i=0;i<V.length;i++){
//   System.out.print("  "+list[i]);
//  }
  for(int i=0;i<V.length;i++){
   if(V[list[i]].color==GraphColor.WHITE){
    flag[list[i]]=list[i];
    DFSVisit(GT,V,list[i]);
    System.out.print("  "+list[i]);
    for(int j=0;j<flag.length;j++){
     if(V[j].color==GraphColor.BLACK && flag[j]==-1){
      flag[j]=list[i];
     }
    }
   }
  }
  printStronglyConnectedComponents(flag);
 }

 private static void printStronglyConnectedComponents(int[] flag) {
  System.out.println("********************强连通分支********************");
  for(int i=0;i<flag.length;i++){
   System.out.print(i+":"+flag[i]+"  ");
  }
 }

 private static void DFS(ListItem[] G, Vertice[] V) {
  time=0;
  for(int i=0;i<V.length;i++){
   if(V[i].color==GraphColor.WHITE){
    DFSVisit(G,V,i);
   }
  }
 }

 private static void DFSVisit(ListItem[] G, Vertice[] V, int u) {
  V[u].color=GraphColor.GRAY;
  time++;
  V[u].d=time;
  ListItem temp=G[u];
  while(temp!=null){
   if(temp.This.color==GraphColor.WHITE){
    temp.This.p=u;
    DFSVisit(G,V,temp.This.index);
   }
   temp=temp.Next;
  }
  V[u].color=GraphColor.BLACK;
  time++;
  V[u].f=time;
 }

 private static void print(Vertice[] v) {
  System.out.println("index" + "  " + "d" + "  " +"f"+"  "+ "color" + "  " + "p");
  for (int i = 0; i < v.length; i++) {
   System.out.println(v[i].index + "      " + v[i].d + "  "+v[i].f+"  "
     + v[i].color + "  " + v[i].p);
  }
 }

 private static void printPath(Vertice[] V, int s, int v) {
  if (s == v) {
   System.out.print(s + "  ");
  } else if (V[v].p == -1) {
   System.out.print("No path from s to v exists.");
  } else {
   printPath(V, s, V[v].p);
   System.out.print(v + "  ");
  }
 }

 private static void BFS(ListItem[] G, Vertice[] V, int s) {
  V[s].color = GraphColor.GRAY;
  V[s].d = 0;
  V[s].p = -1;
  ArrayBlockingQueue<Vertice> queue = new ArrayBlockingQueue<Vertice>(10);
  queue.clear();
  queue.add(V[s]);
  Vertice temp;
  while (!queue.isEmpty()) {
   temp = queue.poll();
   ListItem t = G[temp.index];
   while (t != null) {
    if (t.This.color == GraphColor.WHITE) {
     t.This.color = GraphColor.GRAY;
     t.This.d = temp.d + 1;
     t.This.p = temp.index;
     queue.add(t.This);
    }
    t = t.Next;
   }
   temp.color = GraphColor.BLACK;
  }
 }

 private static void topologicalSort(ListItem[] G, Vertice[] V){
  DFS(G,V);
  int[] list=new int[V.length*2+1];
  for(int i=0;i<list.length;i++){
   list[i]=-1;
  }
  for(int i=0;i<V.length;i++){
   list[V[i].f]=i;
  }
  int temp;
  int index=0;
  for(int i=0;i<list.length;i++){
   if(list[i]!=-1){
    temp=list[i];
    list[i]=list[index];
    list[index]=temp;
    index++;
   }
  }
  for(int i=0;i<V.length/2;i++){
   temp=list[i];
   list[i]=list[V.length-i-1];
   list[V.length-1-i]=temp;
  }
  System.out.println("****************拓扑序列为******************");
  for(int i=0;i<V.length;i++){
   System.out.print(list[i]+"  ");
  }
  System.out.println();
 }
 private static void print(ListItem[] G) {
  ListItem temp;
  for (int i = 0; i < G.length; i++) {
   temp = G[i];
   System.out.print(i+":");
   while (temp != null) {
    System.out.print(temp.This.index+"  ");
    temp = temp.Next;
   }
   System.out.println();
  }
 }
}