图上常用的算法集合

上篇 介绍了图的常用API 和实现了 图的两种方式

下面完成图的常用算法

图的遍历 ——》深度优先 广度优先

最小生成树——》 Prim算法 Kruskral算法

图的最短路径 --> Dijstra 算法 Floyd算法

图的拓扑排序

package lee.graph;

import lee.tools.CircleQueue;
import lee.tools.LinkedQueue;
import lee.tools.Queue;
import lee.tools.UF;

public class GraphAlgorithms {

public static   void DFS_Traversal(Graph g ,int v){
int n=g.getNumVertex();
boolean[] visited = new boolean
;
for(int i=0; i<n;i++){
visited[i]=false;
}

DFS(g , visited ,v);
}

public static void DFS(Graph g, boolean[] visited, int v){
visited[v] = true;
System.out.println("visited-->"+v);
int w = g.getFirstNeighbor(v);
while(w!=-1){
if(!visited[w]){
visited[w]=true;
DFS(g,visited,w);
}
w = g.getNextNeighbor(v,w);
}
}

public static void BFS(Graph g,int v){
boolean[] visited = new boolean[g.getNumVertex()];
for(int i=0;i<g.getNumVertex();i++){
visited[i]=false;
}
visited[v]=true;
Queue q = new CircleQueue();
q.enQuene(v);
while(!q.isEmpty()){
v = q.deQueue();
System.out.println("visited->>"+v);
int w = g.getFirstNeighbor(v);
while(w!=-1){
if(!visited[w]){
q.enQuene(w);
visited[w]=true;
}
w = g.getNextNeighbor(v, w);
}
}
}

public static MSTNode[] prim(Graph g ){
MSTNode[] mstArr = new MSTNode[g.getNumVertex()-1];
int count=0;
boolean[] mstSet = new boolean[g.getNumVertex()];
for(int i=0;i<g.getNumVertex();i++){
mstSet[i] = false;
}
mstSet[0] = true;
MSTHeap heap = new MSTHeap(g.getNumVertex()*2);
int v=0;  //begin Vertex
while(count<g.getNumVertex()-1){
int w = g.getFirstNeighbor(v);
while(w!=-1){
if(!mstSet[w] && g.getWeight(v, w)!=999 ){
heap.insert(new MSTNode(v, w, g.getWeight(v, w)));
}
w = g.getNextNeighbor(v, w);
}
while(!heap.isEmpty()&&count<g.getNumVertex()-1){
MSTNode top = heap.getTop();
if(!mstSet[top.tail]){
mstArr[count++] = top;
mstSet[top.tail]=true;
v=top.tail;
break;
}
}
}
return mstArr;
}

public static MSTNode[] kruskal(Graph g){
MSTNode[] mstArr = new MSTNode[g.getNumVertex()-1];
UF uf = new UF(g.getNumVertex());
MSTHeap heap = new MSTHeap(g.getNumEdge()*2);
int count = 0;
for(int i=0;i<g.getNumVertex();i++){
int w = g.getFirstNeighbor(i);
while(w!=-1 && g.getWeight(i, w)!=999  ){
heap.insert(new MSTNode(i, w, g.getWeight(i, w)));
w = g.getNextNeighbor(i, w);
}
}
MSTNode top = heap.getTop();
while(!heap.isEmpty() && uf.count!=1){
if(!uf.connected(top.front, top.tail)){
uf.union(top.front, top.tail);
mstArr[count++] = top;
}
top = heap.getTop();
}
return mstArr;
}

public static Graph floyd(Graph g){
for(int i =0;i<g.getNumVertex();i++){
for(int j=0;j<g.getNumVertex();j++){
for(int k=0;k<g.getNumVertex();k++){
int weight = g.getWeight(j, k);
int weightI = g.getWeight(j, i)+g.getWeight(i, k);
if(weight>weightI){
g.setWeight(j, k,weightI);
}
}
}
}
return g;
}

public static int[] topologicalSort(Graph g){
int[] inDegree = new int[g.getNumVertex()];
int [] sortResult = new int[g.getNumVertex()];
int count = 0 ;
Queue queue = new LinkedQueue();
for(int i=0; i<g.getNumVertex();i++){
inDegree[i] = g.getInDegree(i);
if(inDegree[i]==0){
queue.enQuene(i);
}
}

while(!queue.isEmpty()){
int v = queue.deQueue();
sortResult[count++] = v;
int w = g.getFirstNeighbor(v);
while(w!=-1){
inDegree[w]--;
if(inDegree[w]==0){
queue.enQuene(w);
}
w = g.getNextNeighbor(v, w);
}
}
return sortResult;
}

public static void dijsktra(Graph g,int v,int[] dist,int[] path){
//	int dist[] = new int[g.getNumVertex()];
//	int path[]= new int[g.getNumVertex()];
boolean[] set = new boolean[g.getNumVertex()];
for(int i=0; i<g.getNumVertex(); i++){
dist[i] = g.getWeight(v, i);
set[i] = false;
path[i] =i;

}
set[v] = true;
dist[v] = 0;

int count=0;
while(count<g.getNumVertex()-1){
int min = 999;
int min_i = -1;
for(int i=0; i<g.getNumVertex(); i++){
if(!set[i] && dist[i]<min){
min = dist[i];
min_i = i;
}
}

set[min_i] = true;
for(int j=0; j<g.getNumVertex(); j++){
if(!set[j] && dist[j]>dist[min_i]+g.getWeight(min_i, j)){
dist[j] = dist[min_i]+g.getWeight(min_i, j);
path[j] = min_i;
}
}
count ++;
}
//	return dist;
}

}