用邻接表实现图的深度优先遍历、广度优先遍历、最短路径（无权图）

Java代码  



import java.util.ArrayList;  

import java.util.LinkedList;  

import java.util.List;  

import java.util.Stack;  

  

public class Graph {  

  

  

    /**关键字：图 邻接表 深度优先遍历 广度优先遍历 最短路径 

     * key words:Graph Adjacent-list depthFirstVisit breadthFirstVisit getCheapestPath 

     * 1.Graph is a collection of Vertex and Edge. 

     * When you want to implement 'Graph',you deal with two missions:how to implement 'Vertex' and 'Edge' 

     *  a.Vertex: 

     *    Type label-->Vertex's ID,to separate one Vertex from another,like 'A','B',or 0,1,2 

     *    List<Edge> edgeList-->store edges that start with this Vertex. 

     *    ...<output omit> 

     *  b.Edge(as Inner class of Vertex): 

     *    endVertex-->(begin,end),the outer class is 'begin',endVertex is 'end' 

     *    ...<output omit> 

     * 2.In the following,we  

     *  a.use ArrayList to store Vertices 

     *  b.use 'char' as Vertex's ID 

    */  

    private List<Vertex> vertices;  

    private int edgeCount;  

    private List<Vertex> depthFirstResult;  

    private List<Vertex> breadthFirstResult;  

      

public void breadthFirstVisit(char beginLabel){  

          

        Vertex origin=this.getVertexByChar(beginLabel);  

        if(origin==null)return;  

        List<Vertex> queue=new LinkedList<Vertex>();  

        origin.setVisited(true);  

        queue.add(origin);  

        breadthFirstResult.add(origin);  

        Vertex curVertex=null;  

        while(!queue.isEmpty()){  

            curVertex=queue.remove(0);  

            while(curVertex.getFirstUnvisitedNeighbor()!=null){  

                Vertex tmpVertex=curVertex.getFirstUnvisitedNeighbor();  

                tmpVertex.setVisited(true);  

                queue.add(tmpVertex);  

                breadthFirstResult.add(tmpVertex);  

            }  

              

        }  

        printVertexList(breadthFirstResult);  

}  

      

    public void depthFirstVisit(char beginLabel){  

          

        Vertex origin=this.getVertexByChar(beginLabel);  

        if(origin==null)return;  

        Stack<Vertex> stack=new Stack<Vertex>();  

        origin.setVisited(true);  

        stack.push(origin);  

        depthFirstResult.add(origin);  

        Vertex curVertex=null;  

        while(!stack.isEmpty()){  

            curVertex=stack.peek();  

            Vertex tmpVertex=curVertex.getFirstUnvisitedNeighbor();  

            if(tmpVertex!=null){  

                tmpVertex.setVisited(true);  

                depthFirstResult.add(tmpVertex);  

                stack.push(tmpVertex);  

            }else{  

                stack.pop();  

            }  

        }  

        printVertexList(depthFirstResult);  

    }  

      

    //getShortestPath.Base on breadthFirstVisit.the edge has no weight.  

    public double getShortestPath(char beginLabel,char endLabel,Stack<Vertex> stack){  

        resetVertices();  

        Vertex begin=this.getVertexByChar(beginLabel);  

        Vertex end=this.getVertexByChar(endLabel);  

        begin.setVisited(true);  

        List<Vertex> queue=new LinkedList<Vertex>();  

        queue.add(begin);  

        boolean done=false;  

        while(!done&&!queue.isEmpty()){  

            Vertex curVertex=queue.remove(0);  

            while(!done&&curVertex.getFirstUnvisitedNeighbor()!=null){  

                Vertex tmpVertex=curVertex.getFirstUnvisitedNeighbor();  

                tmpVertex.setVisited(true);  

                double  tmpCost=curVertex.getCost()+1;  

                tmpVertex.setPreviousVertex(curVertex);  

                tmpVertex.setCost(tmpCost);  

                queue.add(tmpVertex);  

                if(tmpVertex.equals(end)){  

                    done=true;  

                }  

            }  

        }  

        double pathLength=end.getCost();  

        //find the path.traverse back from end  

        while(end!=null){  

            stack.push(end);  

            end=end.getPreviousVertex();  

        }  

        return pathLength;  

    }  

      

    public boolean addEdge(char beginLabel,char endLabel,double weight){  

        int beginIndex=vertices.indexOf(new Vertex(beginLabel));  

        int endIndex=vertices.indexOf(new Vertex(endLabel));  

        Vertex beginVertex=vertices.get(beginIndex);  

        Vertex endVertex=vertices.get(endIndex);  

        boolean result=beginVertex.connect(endVertex,weight);  

        edgeCount++;  

        return result;  

    }  

    public boolean addEdge(char beginLabel,char endLabel){  

        return addEdge(beginLabel,endLabel,0);  

    }  

    public boolean addVertex(char label){  

        boolean result=false;  

        Vertex newVertex=new Vertex(label);  

        if(!vertices.contains(newVertex)){  

            vertices.add(newVertex);//reject duplicate vertex  

            result=true;  

        }  

        return result;  

    }  

    public void printVertexList(List<Vertex> list){  

        for(int i=0,len=list.size();i<len;i++){  

            Vertex vertex=list.get(i);  

            System.out.print(vertex.getLabel()+" ");  

        }  

        System.out.println();  

    }  

      

    public void resetVertices(){  

        for(int i=0,len=vertices.size();i<len;i++){  

            Vertex vertex=vertices.get(i);  

            vertex.setPreviousVertex(null);  

            vertex.setVisited(false);  

            vertex.setCost(0);  

        }  

    }  

      

    public Vertex getVertexByChar(char target){  

        Vertex vertex=null;  

        for(int i=0,len=vertices.size();i<len;i++){  

            vertex=vertices.get(i);  

            Character xx=vertex.getLabel();  

            if(xx.charValue()==target){  

                return vertex;  

            }  

        }  

        return vertex;  

    }  

      

    public Graph(){  

        vertices=new ArrayList<Vertex>();  

        edgeCount=0;  

        depthFirstResult=new ArrayList<Vertex>();  

        breadthFirstResult=new ArrayList<Vertex>();  

    }  

  

      

      

    public static void main(String[] args) {  

          

        Graph graph=createGapth();  

        graph.depthFirstVisit('7');//depthFirstVisit,start with '7'  

        graph.resetVertices();  

        graph.breadthFirstVisit('0');//breadthFirstVisit,start with '0'  

          

        //shortest path  

        Stack<Vertex> pathStack=new Stack<Vertex>();  

        //from '0' to '7'.  

        double pathLength=graph.getShortestPath('0','7',pathStack);  

        System.out.println(pathLength);  

        while(!pathStack.isEmpty()){  

            Vertex vertex=pathStack.pop();  

            System.out.print(vertex.getLabel()+" ");  

        }  

          

        //BasicGraphInterface<String> airMap=new UndirectedGraph<String>();  

        //airMap.  

          

    }  

      

    public static Graph createGapth(){  

        /* 

         0----1---2 

         | \  |   | 

         |  \ |   | 

         |   \|   | 

         3    4   5 

         |   / 

         |  / 

         | / 

         6---7 

         the adjacent List is : 

         0-->4--3--1 

         1-->4--2--0 

         2-->5--1 

         3-->6--0 

         4-->6--1--0 

         5-->2 

         6-->7--4--3 

         7-->6 

         */  

          

        Graph graph=new Graph();  

        graph.addVertex('0');  

        graph.addVertex('1');  

        graph.addVertex('2');  

        graph.addVertex('3');  

        graph.addVertex('4');  

        graph.addVertex('5');  

        graph.addVertex('6');  

        graph.addVertex('7');  

          

        graph.addEdge('0','4');  

        graph.addEdge('0','3');  

        graph.addEdge('0','1');  

          

        graph.addEdge('1','4');  

        graph.addEdge('1','2');  

        graph.addEdge('1','0');  

          

        graph.addEdge('2','5');  

        graph.addEdge('2','1');  

          

        graph.addEdge('3','6');  

        graph.addEdge('3','0');  

          

        graph.addEdge('4','6');  

        graph.addEdge('4','1');  

        graph.addEdge('4','0');  

          

        graph.addEdge('5','2');  

          

        graph.addEdge('6','7');  

        graph.addEdge('6','4');  

        graph.addEdge('6','3');  

          

        graph.addEdge('7','6');  

          

        return graph;  

    }  

}  

  

  

class Vertex{  

    private char label;  

    private List<Edge> edgeList;  

    private boolean isVisited;  

    private Vertex previousVertex;//use it in the method-'getShortestPath()'  

    private double cost;//the cost from beginning to this vertex   

      

    public Vertex(char label){  

        this.label=label;  

        edgeList=new ArrayList<Edge>();  

        isVisited=false;  

        previousVertex=null;  

        cost=0;  

    }  

    public boolean isVisited(){  

        return isVisited;  

    }  

    public void visit(){  

        System.out.println(this.label);  

        this.isVisited=true;  

    }  

      

    public void setPreviousVertex(Vertex vertex){  

        this.previousVertex=vertex;  

    }  

    public void setVisited(Boolean isVisited){  

        this.isVisited=isVisited;  

    }  

    public void setCost(double cost){  

        this.cost=cost;  

    }  

    public Vertex getFirstNeighbor(){  

        Vertex neighbor=this.edgeList.get(0).endVertex;  

        return neighbor;  

    }  

    public char getLabel(){  

        return this.label;  

    }  

      

    public double getCost(){  

        return this.cost;  

    }  

    public Vertex getPreviousVertex(){  

        return this.previousVertex;  

    }  

    public Vertex getFirstUnvisitedNeighbor(){  

        Vertex unVisitedNeighbor=null;  

        for(int i=0,len=edgeList.size();i<len;i++){  

            Vertex vertex=edgeList.get(i).endVertex;  

            if(!vertex.isVisited){  

                unVisitedNeighbor=vertex;  

                break;  

            }  

        }  

        return unVisitedNeighbor;  

    }  

    public boolean equals(Object object){  

        boolean result=false;  

        if(this==object)return true;  

        if(object instanceof Vertex){  

            Vertex otherVertex=(Vertex)object;  

            result=this.label==otherVertex.label;  

        }  

        return result;  

    }  

    public boolean connect(Vertex endVertex,double weight){  

          

        boolean result=false;//result=true if successful  

          

        if(!this.equals(endVertex)){//connections should occur in different Vertices  

            boolean isDuplicateEdge=false;  

            List<Edge> edgeList=this.edgeList;  

            if(edgeList.contains(endVertex)){  

                isDuplicateEdge=true;  

            }  

            if(!isDuplicateEdge){  

                //endVertex.previousVertex=this;  

                edgeList.add(new Edge(endVertex,weight));  

                result=true;  

            }  

        }  

              

        return result;  

    }  

      

    public boolean hasNeighbor(){  

        return !edgeList.isEmpty();  

    }  

    protected  class Edge{  

        //A-->B,then the "outerClass" which invokes the method "getEndVertex"   

        //is "A",the "endVertex" is "B"  

        private Vertex endVertex;  

        private double weight;  

          

        protected Edge(Vertex endVertex,double weight){  

            this.endVertex=endVertex;  

            this.weight=weight;  

        }  

        protected Vertex getEndVertex(){  

            return endVertex;  

        }  

        protected double getWeight(){  

            return weight;  

        }  

          

    }  

}