图

基本概念

邻接：如果两个顶点被同一条边连接，就称这两条边是邻接的。

路径：路径是边的序列。

连通图：如果至少有一条路径可以连接起图中的所有顶点，就称图为连通图。

极大连通子图：非连通图中包含几个连通图，其中包含最多顶点的称为极大连通子图。

一般用两种方法表示图：邻接矩阵和邻接表。（如果两个顶点被同一条边连接就称这两个顶点是邻接的）。

邻接矩阵：使用二维数组表示各顶点之间是否有边，可以约定0表示没有边连接，1表示有边连接。

 

邻接表：邻接表是一个链表数组，每个单独的链表表示有哪些顶点与当前顶点邻接（形式上很像哈希表中处理冲突的链地址法）。将与顶点v邻接的顶点存放在一个单独的链表中，再使顶点v包含指向这个链表的指针即可。可以使用Map存储邻接表，HashMap<T, Map<T, double>>。

 

其中，B——>C——>D只是表示A的邻接顶点是B，C，D并不是B指向C，C指向D。

邻接矩阵和邻接表的比较

设图G含有n个顶点e条边，下面比较邻接矩阵和邻接表的存储结构。

空间性能比较

邻接矩阵是一个n*n的矩阵，存储了所有可能的边，所以空间代价是O(n^2)。邻接表是对所有顶点的存储和边的存储，所以其空间代价是O(n+e)。

时间性能比较

图算法中查找某顶点的邻接顶点是常见操作，如果使用邻接矩阵，就需要遍历此顶点对应的一行数组元素，平均查找次数为O(n)。如果使用邻接表，只需要查找顶点对应的邻接表，平均查找次数是O(e/n)。

小结

总之，邻接表是图的标准存储方式，而邻接矩阵的存储方式便于编程。当图是稀疏图时，边的数量远小于顶点的数量，使用邻接矩阵的话，会导致存储空间的极大浪费，并且查找效率也更低下，此时采用邻接表的方法。当图是稠密图时，为了便于编程，可以使用邻接矩阵的方法。

顶点的表示

顶点类的实现对深搜、广搜以及迪杰斯特拉算法的实现具有重要的作用，这里给出顶点类的具体实现，其中有两个标志字段，标识顶点是否已被访问(搜索算法中使用)和顶点是否已加入集合S(迪杰斯特拉算法中使用)，代码如下：

class Vertex{
    char label;//顶点标签
    boolean wasVisited;//顶点访问标记
    boolean insertedIntoS;//迪杰斯特拉算法中，表示此顶点是否已加入集合S中。
    public Vertex(char label){
        this.label=label;
        wasVisited=false;
        insertedIntoS=false;
    }
}

深度优先搜索

　　深度优先搜索是图的一种搜索算法，从起始顶点开始想着距离顶点“更远”的方向搜索可以到达的顶点。深搜使用栈来完成，利用栈来“记住”访问过的顶点，以栈空作为搜索结束的条件。步骤如下：

1)从搜索从起始顶点开始，将顶点标记为已访问，并入栈

2）如果栈顶元素有邻接顶点并且未被访问，将顶点标记为已访问，输出顶点标签并入栈，直到不满足前述条件转3。

3）如果栈不空，将栈顶元素出栈，转2

4）最后栈空时，搜索结束。

5）//将顶点访问标记重置为false，便于下次搜索使用

总结：
每次出栈时，就到达离起始点“较远”的一个顶点，通过比较每次出栈时顶点与起始点的距离可以得到图中
离起始点“最远”的顶点
每次入栈时，就是访问了一个顶点，所以入栈时，将顶点输出，最终就得到了深度优先搜索的访问序列。
任意时刻，栈的内容是从起始顶点到栈顶顶点所经过的所有顶点，也就是一条路径。

代码实现如下：

/*
    深度优先搜索使用栈来完成，使用栈来“记住”访问过的顶点，以栈空作为搜索结束的条件，步骤如下
    1)从搜索从起始顶点开始，将顶点标记为已访问，并入栈
    2）如果栈顶元素有邻接顶点并且未被访问，将顶点标记为已访问，输出顶点标签并入栈，直到不满足前述条件转3。
    3）如果栈不空，将栈顶元素出栈，转2
    4）最后栈空时，搜索结束。
    5）//将顶点访问标记重置为false，便于下次搜索使用

    总结：
    每次出栈时，就到达离起始点“较远”的一个顶点，通过比较每次出栈时顶点与起始点的距离可以得到图中
    离起始点“最远”的顶点
    每次入栈时，就是访问了一个顶点，所以入栈时，将顶点输出，最终就得到了深度优先搜索的访问序列。
    任意时刻，栈的内容是从起始顶点到栈顶顶点所经过的所有顶点，也就是一条路径。
     */
    public void dfs(){//从起始点0(A)开始搜索
        System.out.println("dfs:");
      Stack<Integer> stack=new Stack<>();
        vertexArray[0].wasVisited=true;
        stack.push(0);
        System.out.print(vertexArray[0].label);
        int adjNumber=-1;
        while (!stack.isEmpty()){
            adjNumber=getAdjUnvisitedVertex(stack.peek());//得到栈顶元素的下一个未被访问的邻接点
            if(adjNumber==-1){
                stack.pop();//栈顶元素没有邻接点，访问到距离起始点较远的顶点
            }
            else {
                vertexArray[adjNumber].wasVisited=true;
                System.out.print("\t" + vertexArray[adjNumber].label);
                stack.push(adjNumber);//将栈顶元素的未被访问的邻接点入栈

            }
        }
        //将访问标记重置为false，便于下次搜索使用
        for (int i = 0; i <nVertexs ; i++) {
            vertexArray[i].wasVisited=false;
        }
    }

深度优先搜索得到距离起始点最远的顶点，然后再不能前进的时候返回。使用深度优先搜索可以解决迷宫问题。

广度优先搜索

　　图的广度优先搜索使用队列来实现，与深度优先搜索类似，以队空作为搜索结束的条件，任意时刻，
队列中的顶点是那些已经被访问过，其邻接点还未被访问过的顶点。步骤如下：
1)将起始顶点标记为已访问，并将其入队。
2）如果队不空，得到队首元素所有未被访问过的顶点，将其标记为已访问，输出对应标签，最后依次入队
3）如果队首元素邻接顶点全部入队，将队首元素出队，得到新的队首元素，转2
4）最后队空时，搜索结束。
5）将访问标记重置为false，便于下次搜索使用

代码实现如下：

 public void bfs2(){
        Queue<Integer> queue=new LinkedList<>();
        vertexArray[0].wasVisited=true;
        System.out.print("\nbfs:" + "\n" + vertexArray[0].label);
        queue.add(0);//将起始点入队
        int adjNumber=-1;
        while (!queue.isEmpty()){
            while ((adjNumber=getAdjUnvisitedVertex(queue.peek()))!=-1){//队首顶点的未被访问的邻接顶点
                vertexArray[adjNumber].wasVisited=true;
                System.out.print("\t" + vertexArray[adjNumber].label);
                queue.add(adjNumber);//队首元素未访问过的邻接点入队
            }
            queue.remove();
        }
        //将访问标记重置为false，便于下次搜索使用
        for (int i = 0; i <nVertexs ; i++) {
            vertexArray[i].wasVisited=false;
        }
    }

迪杰斯特拉算法

　　Dijkstra算法用于求单源点最短路径问题，问题描述如下：给定的带权有向图G=(V,E)和源点v，求从v到G中其余各顶点的最短路径。

算法描述

设D(v)是从源点s到顶点v的距离

I(v,w)是从顶点v到顶点w的距离

如两顶点之间无边，就认为两点之间距离为正无穷(或者赋给一个很大的值)。

算法如下：

1.设S={s},以集合S存放已经找到源点到其的最短路径的顶点，初始状态下，S中只包含源点s。对不再S中的每一个顶点，另D(v)=I(s,v)。

对那些与s不邻接的顶点赋值为∞。

2.找到不在集合S中的顶点，比较其D(v)值，得到具有最小值的节点w，如果D(w)=∞，说明已经得到了所有源点可以到达的顶点，算法结束。否则，将w加入集合S中，表示已找到源点到w的最短路径，然后对不在集合S的其余顶点，利用w更新D(v)：

D(v)=min([D(v),D(w)+I(w,v)])

重复2，知道所有顶点都在S中。

算法实现

使用DistPar类来保存从源点到此顶点的最短距离以及最短路径上的父顶点，DistPar[] dist，，具体实现如下：

class DistPar{//保存从源点到此顶点的最短距离以及最短路径上的父顶点
     int distance;//最短距离
     int parentVertexindex;//父顶点
    public DistPar(int distance,int parentVertexindex){
        this.distance=distance;
        this.parentVertexindex=parentVertexindex;
    }

求dist数组中离源点最近的顶点，并且是未加入集合S中的顶点，getMin实现如下：

 //要求邻接矩阵中使用1e6(infinity)表示两顶点不邻接，没有边连接。
    /*
    求dist数组中离源点最近的顶点，并且是未加入集合S中的顶点。
     */
    public int getMin(DistPar[] dist,int len){
        int minValue=(int)1e6;//
        int minIndex=-1;
        for (int i = 1; i <len ; i++) {
            if(!vertexArray[i].insertedIntoS&&dist[i].distance<minValue){
                minIndex=i;
                minValue=dist[i].distance;
            }
        }
        return minIndex;
    }

根据刚加入S的顶点，更新dist,已经标记为加入集合S的顶点不用更新，adjustDist实现如下：

/*
    根据刚加入S的顶点，更新dist,已经标记为加入集合S的顶点不用更新
     */

    public void adjustDist(DistPar[] dist,int len,int insertedVertexIndex){
        for (int i = 0; i <len ; i++) {
            if(!vertexArray[i].insertedIntoS&&adjMat[insertedVertexIndex][i]+dist[insertedVertexIndex].distance
                    <dist[i].distance){
                dist[i].distance=adjMat[insertedVertexIndex][i]+dist[insertedVertexIndex].distance;
                dist[i].parentVertexindex=insertedVertexIndex;
            }
        }
    }

算法收敛条件有两个，图中所有顶点已加入S中或者getMin得到的最小值是∞，说明已经没有源点可到达的顶点，算法主体实现如下：

 //迪杰斯特拉算法:求解单源最短路径问题，求图中某点v到其余顶点的最短路径。
    public void dijkstra(int sourceVertexIndex){
        DistPar[] dist=new DistPar[nVertexs];
        int insertedIntoVertexs=0;
        vertexArray[sourceVertexIndex].insertedIntoS=true;//把源点加入集合S中
        ++insertedIntoVertexs;//对集合S中顶点数量计数
        for (int i = 0; i <nVertexs; i++) {
            int temp=adjMat[sourceVertexIndex][i];
            dist[i]=new DistPar(temp,sourceVertexIndex);//把与源点邻接的各顶点的权值拷贝到dist中
        }
        int minIndex=-1;
        while (insertedIntoVertexs<nVertexs){//源点可以到达所有其他顶点，将这些顶点加入集合S
            minIndex=getMin(dist,nVertexs);//得到集合S外的顶点中，源点可到的距离最短的顶点索引
            if(minIndex==-1){//除S外，已经没有源点可到的顶点，算法结束
                System.out.println("no more reachable vertexs");
                break;
            }
            else {
                ++insertedIntoVertexs;//计数，表示向S中加入一个顶点
                vertexArray[minIndex].insertedIntoS=true;//将顶点标记为已加入集合S
                adjustDist(dist,nVertexs,minIndex);
            }
        }
        System.out.println("迪杰斯特拉算法已完成");
        //算法结束，重置顶点加入S标志，便于下次使用
        for (int i = 0; i <nVertexs ; i++) {
            vertexArray[i].insertedIntoS=false;
        }
    }

Dijkstra应用实例

完整程序(dfs、bfs、Dijkstra)

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

/**
 * Created by hfz on 2016/8/24.
 */
public class graph {
    private int MAX_VERTEXS=20;//最多顶点数
    private Vertex[] vertexArray;//存储顶点的数组
    private int[][] adjMat;//邻接矩阵
    private int nVertexs;//图中当前顶点数量

    public graph(){
        vertexArray=new Vertex[MAX_VERTEXS];
        adjMat=new int[MAX_VERTEXS][MAX_VERTEXS];
        nVertexs=0;
        for (int i = 0; i <MAX_VERTEXS ; i++) {
            for (int j = 0; j <MAX_VERTEXS ; j++) {
                adjMat[i][j]=(int)1e6;
            }
        }
    }

    public void addVertex(char label){
        vertexArray[nVertexs++]=new Vertex(label);
    }
    /*
    根据顶点的label，按照字母顺序，将节点以0，1.。。n-1简单编号，利用这些编号创建边和求解未被访问的
    邻接顶点。起始点对应编号是0
    */
    public void addEdge(int start,int end){
        adjMat[start][end]=1;
        adjMat[end][start]=1;
    }

    public void addEdge(int start,int end,int weight){
        adjMat[start][end]=weight;
    }

    //得到相邻的未被访问的顶点索引值(根据字母序将标签分别映射为0,1...n-1)
    public int getAdjUnvisitedVertex(int v){
        for (int i = 0; i <nVertexs ; i++) {
            if(adjMat[v][i]==1&&vertexArray[i].wasVisited==false){
                return i;
            }
        }
        return -1;
    }

    /*
    深度优先搜索使用栈来完成，使用栈来“记住”访问过的顶点，以栈空作为搜索结束的条件，步骤如下
    1)从搜索从起始顶点开始，将顶点标记为已访问，并入栈
    2）如果栈顶元素有邻接顶点并且未被访问，将顶点标记为已访问，输出顶点标签并入栈，直到不满足前述条件转3。
    3）如果栈不空，将栈顶元素出栈，转2
    4）最后栈空时，搜索结束。
    5）//将顶点访问标记重置为false，便于下次搜索使用

    总结：
    每次出栈时，就到达离起始点“较远”的一个顶点，通过比较每次出栈时顶点与起始点的距离可以得到图中
    离起始点“最远”的顶点
    每次入栈时，就是访问了一个顶点，所以入栈时，将顶点输出，最终就得到了深度优先搜索的访问序列。
    任意时刻，栈的内容是从起始顶点到栈顶顶点所经过的所有顶点，也就是一条路径。
     */
    public void dfs(){//从起始点0(A)开始搜索
        System.out.println("dfs:");
      Stack<Integer> stack=new Stack<>();
        vertexArray[0].wasVisited=true;
        stack.push(0);
        System.out.print(vertexArray[0].label);
        int adjNumber=-1;
        while (!stack.isEmpty()){
            adjNumber=getAdjUnvisitedVertex(stack.peek());//得到栈顶元素的下一个未被访问的邻接点
            if(adjNumber==-1){
                stack.pop();//栈顶元素没有邻接点，访问到距离起始点较远的顶点
            }
            else {
                vertexArray[adjNumber].wasVisited=true;
                System.out.print("\t" + vertexArray[adjNumber].label);
                stack.push(adjNumber);//将栈顶元素的未被访问的邻接点入栈

            }
        }
        //将访问标记重置为false，便于下次搜索使用
        for (int i = 0; i <nVertexs ; i++) {
            vertexArray[i].wasVisited=false;
        }
    }

    /*
    图的广度优先搜索使用队列来实现，与深度优先搜索类似，以队空作为搜索结束的条件，任意时刻，
    队列中的顶点是那些已经被访问过，其邻接点还未被访问过的顶点。步骤如下：
    1)将起始顶点标记为已访问，并将其入队。
    2）如果队不空，得到队首元素所有未被访问过的顶点，将其标记为已访问，输出对应标签，最后依次入队
    3）如果队首元素邻接顶点全部入队，将队首元素出队，得到新的队首元素，转2
    4）最后队空时，搜索结束。
    5）将访问标记重置为false，便于下次搜索使用
     */
    public void bfs(){
        Queue<Integer> queue=new LinkedList<>();
        vertexArray[0].wasVisited=true;
        System.out.print("\nbfs:" + "\n" + vertexArray[0].label);
        queue.add(0);//将起始点入队
        int adjNumber=-1;
        while (!queue.isEmpty()){
            adjNumber=getAdjUnvisitedVertex(queue.peek());//队首顶点的未被访问的邻接顶点
            if(adjNumber==-1){
                queue.remove();//队首元素的所有邻接点入队之后，队首元素出队。
            }
            else {
                vertexArray[adjNumber].wasVisited=true;
                System.out.print("\t" + vertexArray[adjNumber].label);
                queue.add(adjNumber);//队首元素未访问过的邻接点入队
            }
        }
        //将访问标记重置为false，便于下次搜索使用
        for (int i = 0; i <nVertexs ; i++) {
            vertexArray[i].wasVisited=false;
        }
    }
    //简洁版本
    public void bfs2(){
        Queue<Integer> queue=new LinkedList<>();
        vertexArray[0].wasVisited=true;
        System.out.print("\nbfs:" + "\n" + vertexArray[0].label);
        queue.add(0);//将起始点入队
        int adjNumber=-1;
        while (!queue.isEmpty()){
            while ((adjNumber=getAdjUnvisitedVertex(queue.peek()))!=-1){//队首顶点的未被访问的邻接顶点
                vertexArray[adjNumber].wasVisited=true;
                System.out.print("\t" + vertexArray[adjNumber].label);
                queue.add(adjNumber);//队首元素未访问过的邻接点入队
            }
            queue.remove();
        }
        //将访问标记重置为false，便于下次搜索使用
        for (int i = 0; i <nVertexs ; i++) {
            vertexArray[i].wasVisited=false;
        }
    }

    //迪杰斯特拉算法:求解单源最短路径问题，求图中某点v到其余顶点的最短路径。
    public void dijkstra(int sourceVertexIndex){
        DistPar[] dist=new DistPar[nVertexs];
        int insertedIntoVertexs=0;
        vertexArray[sourceVertexIndex].insertedIntoS=true;//把源点加入集合S中
        ++insertedIntoVertexs;//对集合S中顶点数量计数
        for (int i = 0; i <nVertexs; i++) {
            int temp=adjMat[sourceVertexIndex][i];
            dist[i]=new DistPar(temp,sourceVertexIndex);//把与源点邻接的各顶点的权值拷贝到dist中
        }
        int minIndex=-1;
        while (insertedIntoVertexs<nVertexs){//源点可以到达所有其他顶点，将这些顶点加入集合S
            minIndex=getMin(dist,nVertexs);//得到集合S外的顶点中，源点可到的距离最短的顶点索引
            if(minIndex==-1){//除S外，已经没有源点可到的顶点，算法结束
                System.out.println("no more reachable vertexs");
                break;
            }
            else {
                ++insertedIntoVertexs;//计数，表示向S中加入一个顶点
                vertexArray[minIndex].insertedIntoS=true;//将顶点标记为已加入集合S
                adjustDist(dist,nVertexs,minIndex);
            }
        }
        System.out.println("迪杰斯特拉算法已完成");
        //算法结束，重置顶点加入S标志，便于下次使用
        for (int i = 0; i <nVertexs ; i++) {
            vertexArray[i].insertedIntoS=false;
        }
    }
    //要求邻接矩阵中使用1e6(infinity)表示两顶点不邻接，没有边连接。
    /*
    求dist数组中离源点最近的顶点，并且是未加入集合S中的顶点。
     */
    public int getMin(DistPar[] dist,int len){
        int minValue=(int)1e6;//
        int minIndex=-1;
        for (int i = 1; i <len ; i++) {
            if(!vertexArray[i].insertedIntoS&&dist[i].distance<minValue){
                minIndex=i;
                minValue=dist[i].distance;
            }
        }
        return minIndex;
    }

    /*
    根据刚加入S的顶点，更新dist,已经标记为加入集合S的顶点不用更新
     */

    public void adjustDist(DistPar[] dist,int len,int insertedVertexIndex){
        for (int i = 0; i <len ; i++) {
            if(!vertexArray[i].insertedIntoS&&adjMat[insertedVertexIndex][i]+dist[insertedVertexIndex].distance
                    <dist[i].distance){
                dist[i].distance=adjMat[insertedVertexIndex][i]+dist[insertedVertexIndex].distance;
                dist[i].parentVertexindex=insertedVertexIndex;
            }
        }
    }
    public static void main(String[] args){
        graph gra=new graph();
        gra.addVertex('A');//0
        gra.addVertex('B');//1
        gra.addVertex('C');//2
        gra.addVertex('D');//3
        gra.addVertex('E');//4
        gra.addEdge(0, 1);
        gra.addEdge(0, 3);
        gra.addEdge(1, 2);
        gra.addEdge(3, 4);
        gra.dfs();
        System.out.println("\n" + "******************");
        graph graph2=new graph();
        graph2.addVertex('A');
        graph2.addVertex('B');
        graph2.addVertex('C');
        graph2.addVertex('D');
        graph2.addVertex('E');
        graph2.addVertex('F');
        graph2.addVertex('G');
        graph2.addVertex('H');
        graph2.addVertex('I');
        graph2.addEdge(0, 1);
        graph2.addEdge(0, 2);
        graph2.addEdge(0, 3);
        graph2.addEdge(0, 4);
        graph2.addEdge(1, 5);
        graph2.addEdge(3, 6);
        graph2.addEdge(5, 7);
        graph2.addEdge(6, 8);
        graph2.dfs();
        System.out.println("\n" + "******************");
        graph2.bfs();
        graph2.bfs2();
        System.out.println("\n" + "******迪杰斯特拉************");
        graph graph3=new graph();
        graph3.addVertex('A');
        graph3.addVertex('B');
        graph3.addVertex('C');
        graph3.addVertex('D');
        graph3.addVertex('E');
        graph3.addEdge(0, 1, 50);
        graph3.addEdge(0, 3, 80);
        graph3.addEdge(1, 2, 60);
        graph3.addEdge(1, 3, 90);
        graph3.addEdge(2, 4, 40);
        graph3.addEdge(3, 2, 20);
        graph3.addEdge(3, 4, 70);
        graph3.addEdge(4, 1, 50);
        graph3.dijkstra(0);

        graph graph4=new graph();
        graph4.addVertex('A');
        graph4.addVertex('B');
        graph4.addVertex('C');
        graph4.addVertex('D');
        graph4.addVertex('E');
        graph4.addEdge(0, 1, 4);
        graph4.addEdge(1, 0, 4);
        graph4.addEdge(0, 2, 5);
        graph4.addEdge(2, 0, 5);
        graph4.addEdge(2, 1, 3);
        graph4.addEdge(1, 2, 3);
        graph4.addEdge(1, 3, 1);
        graph4.addEdge(3, 1, 1);
        graph4.addEdge(3, 2, 2);
        graph4.addEdge(2, 3, 2);
        graph4.addEdge(3, 4, 2);
        graph4.addEdge(4, 3, 2);
        graph4.addEdge(4, 2, 20);
        graph4.addEdge(2, 4, 20);
        graph4.dijkstra(4);
    }
}

class DistPar{//保存从源点到此顶点的最短距离以及最短路径上的父顶点
     int distance;//最短距离
     int parentVertexindex;//父顶点
    public DistPar(int distance,int parentVertexindex){
        this.distance=distance;
        this.parentVertexindex=parentVertexindex;
    }
}
class Vertex{
    char label;//顶点标签
    boolean wasVisited;//顶点访问标记
    boolean insertedIntoS;//迪杰斯特拉算法中，表示此顶点是否已加入集合S中。
    public Vertex(char label){
        this.label=label;
        wasVisited=false;
        insertedIntoS=false;
    }
}

参考：Java数据结构和算法 第二版 Robert Lafore，数据结构（C++版）第二版 王红梅