java版 图的邻接表、邻接矩阵、BFS、DFS 实现

package graph;
import java.util.*;

/*
         图的邻接表类型
 */

//弧的节点结构类型
class ANode{
    int adjVertex;        //指向顶点在adjList的下标
    ANode nextArc;        //指向下一条弧
    int value;            //存放权值
}

//邻接表节点的类型
class VNode{            
    String name;        //顶点信息
    ANode firstArc;        //指向第一条弧
}

//图的邻接表类型
class ALGraph {    
    VNode[] adjList;
    int n;                //图的顶点数n
    int e;                //图的边数e
    
    
    
    public ALGraph(int a,int b){
        this.n = a;
        this.e = b;
        adjList = new VNode[n+1];
        for(int i=1;i<=n;i++)
            adjList[i] = new VNode();
    }
    
    public void disALGraph(ALGraph G){
        for(int i=1;i<=G.n;i++)
        {
            VNode v = G.adjList[i];
            System.out.print(v.name+"->");
            ANode e= v.firstArc;
            while(e!=null)
            {
                System.out.print(G.adjList[e.adjVertex].name+"   ");
                e = e.nextArc;
            }
            System.out.println();
        }
    }
    

//    邻接表的DFS   递归
//--------------------------------------------------------------------
    public void DFSTraval(ALGraph AG,VNode v,int[] visited){
        
        ANode e= v.firstArc;
    
        while(e!=null){
            if(visited[e.adjVertex]==0)
            {
                VNode w = AG.adjList[e.adjVertex];
                visited[e.adjVertex]=1;
            //    System.out.println("Traval :"+w.name);
                DFSTraval(AG,w,visited);
            }
            else
                e=e.nextArc;
        }
        System.out.println("Traval :"+v.name);
    }
    
    public void DFS(ALGraph AG,int[] visited){        //邻接表的DFS
        for(int i=1;i<=n;i++)
        {
            if(visited[i]==0)
            {
                visited[i]=1;
            //    System.out.println("Traval :"+AG.adjList[i].name);
                DFSTraval(AG,AG.adjList[i],visited);
            }
        }
    }
//---------------------------------------------------------------------------

    
    
//    邻接表的DFS   非递归
//---------------------------------------------------------------------------    
    public void DFS2(ALGraph AG,int[] visited){        //邻接表的DFS,使用栈
        Stack<VNode> stack = new Stack<VNode>();
        for(int i=1;i<=n;i++){
            if(visited[i]==0){
                visited[i]=1;
                
            //    System.out.println("Traval :"+AG.adjList[i].name);
                stack.push(AG.adjList[i]);
                VNode v;
                ANode e;
                while(!stack.empty()){
                    v = stack.peek();
                    e= v.firstArc;
                    while(e!=null){
                        if(visited[e.adjVertex]==0)
                        {
                            VNode w = AG.adjList[e.adjVertex];
                            visited[e.adjVertex]=1;
                            
                            stack.push(w);
                            v = w;
                            e= v.firstArc;
                        }
                        else
                            e=e.nextArc;
                    }
                    System.out.println("Traval :"+v.name);
                    stack.pop();
                }
            }
        }    
    }
//-----------------------------------------
4000
----------------------------------
    
    
    
    public void BFS(ALGraph AG,int[] visited){
        Queue<VNode> queue = new LinkedList<VNode>();
        
        visited[1]=1;
        queue.offer(AG.adjList[1]);
        
        VNode v ;
        ANode e;//= v.firstArc;
        while(!queue.isEmpty()){
            v = queue.poll();
            System.out.println(v.name);
            e = v.firstArc;
            while(e!=null){
                if(visited[e.adjVertex]==0){
                    VNode w = AG.adjList[e.adjVertex];
                    visited[e.adjVertex]=1;
                    queue.offer(w);
                }
                e = e.nextArc;
            }
        }
    }

//---------------------------------------------------------------------------    
//Kahn算法
    public void TopoSort(ALGraph AG){
        int n = AG.n;
        int edge = AG.e;
        int[] inDegree = new int[n+1];        //用于记录AG中入度为0的顶点
        for(int i=1;i<=n;i++)
        {
            VNode v = AG.adjList[i];
            ANode e = v.firstArc;
            while(e!=null){
                inDegree[e.adjVertex]++;
                e = e.nextArc;
            }
        }
        
        Queue<VNode> queue = new LinkedList<VNode>();
        for(int i=1;i<=n;i++)
        {
            if(inDegree[i]==0)
                queue.offer(AG.adjList[i]);
        }
        
        while(!queue.isEmpty()){
            VNode v = queue.poll();
            System.out.println("visit :"+ v.name);
            ANode e = v.firstArc;
            while(e!=null){
                inDegree[e.adjVertex]--;
                edge--;
                if(inDegree[e.adjVertex]==0)
                    queue.offer(AG.adjList[e.adjVertex]);
                e = e.nextArc;
            }
        }
    }
//---------------------------------------------------------------------------
    
    
    
    
}
    
class Vertex {
    String name;        //顶点信息
}
    
class MGraph {
    int n;                //图的顶点数n
    int e;                //图的边数e
    int[] vex ;    //顶点数组
    int[][] edges ;    //邻接矩阵
    
    
    
    public MGraph(int a,int b){
        this.n = a;
        this.e = b;
        vex = new int[n+1];
        edges = new int[n+1][n+1];    
        for(int i=1;i<=n;i++)
        {
            edges[i] = new int[n+1];
        }
    }
    
    
    
//邻接矩阵的DFS    
//---------------------------------------------------------------------------    
    public void DFSTraval(MGraph MG,int v,int[] visited){
        for(int i=1;i<=MG.n;i++){
            if(MG.edges[v][i]>0){
                if(visited[i]==0){
                    visited[i]=1;
                //    System.out.println("Traval :"+i);
                    DFSTraval(MG,i,visited);
                }    
            }
            
        }
        System.out.println("Traval :"+v);
    }
        
    public void DFS(MGraph MG,int[] visited){
        for(int i=1;i<=n;i++)
        {
            if(visited[i]==0)
            {
                visited[i]=1;
            //    System.out.println("Traval :"+i);
                DFSTraval(MG,i,visited);    
            }
        }
    }
//---------------------------------------------------------------------------    
    
    
    
//    邻接矩阵的DFS   非递归
//---------------------------------------------------------------------------        
    public void DFS2(MGraph MG,int[] visited){        //邻接表的DFS,使用栈
        Stack stack = new Stack();
        
        int j=0;
        int k=0;
        
        for(int i=1;i<=n;i++){
            if(visited[i]==0){
                visited[i]=1;
            //    System.out.println("Traval :"+i);
                
                stack.push(i);
                
                while(!stack.empty()){
                    
                    j = (int)stack.peek();
                    
                    for(k=1;k<=MG.n;k++){
                        
                        if(MG.edges[j][k]>0 && visited[k]==0){
                            visited[k]=1;
                            
                            stack.push(k);
                            j = k;
                            k=1;
                        }
                    }
                    
                    int tmp = (int)stack.pop();    
                    System.out.println("Traval :"+tmp);
                                    
                }
            }
        }    
    }    
//---------------------------------------------------------------------------    
    
    public void disMGraph (MGraph G){
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                System.out.print(edges[i][j]+" ");
            }
            System.out.println();
        }
    }
    
    
    
}

public class Graph{
    
    
    //邻接矩阵转邻接表
    public static ALGraph MatrixToList(MGraph MG){
        int n = MG.n;
        ALGraph AG = new ALGraph(MG.n,MG.e);
        
        for(int i=1;i<=n;i++)
        {
            AG.adjList[i].name = i+"";
            
            for(int j=1;j<=n;j++)
            {
                if(MG.edges[i][j]!=0){

                    ANode arc = new ANode();
                    arc.adjVertex = j;
                    arc.nextArc = AG.adjList[i].firstArc;
                    arc.value = MG.edges[i][j];
                    
                    AG.adjList[i].firstArc = arc;
                    
                }
            }
        }
        return AG;
    }
    
    <pre name="code" class="html">
//邻接表转邻接矩阵
    public static MGraph ListToMatrix(ALGraph AG){
        MGraph MG = new MGraph(AG.n,AG.e);
        
        for(int i=1;i<=AG.n;i++)
        {
            VNode v = AG.adjList[i];
            ANode e= v.firstArc;
            while(e!=null){
                MG.edges[i][e.adjVertex] = e.value;
                e = e.nextArc;
            }
        }
        return MG;
    }
    
}