《大话数据结构》第七章 图

---

第七章 图

图的定义

定义：图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V, E)，其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。

注意：

1. 图中的数据元素，称为顶点（Vertex）
2. 图结构中不允许没有顶点
3. 任意两个顶点之间都可能有关系，顶点之间的逻辑关系用边表示

无向边：两个顶点之间的边没有方向，就称这边为无向边（Edge），用无序偶对$(v_i,v_j)$表示。
如果所有的顶点之间都是无向边，则这个图为无向图（Undirected graphs）。

有向边：顶点间的边有方向，则称这条边为有向边，也成为弧（Arc）。
如果所有的边都是有向边，则该图称为有向图（Directed graphs）。
由A到D的有向边，A是弧尾，D是弧头，<A, D>表示弧，不可写成<D, A>

注意：无向边是小括号（），有向边是尖括号 <>

简单图：若不存在顶点到其自身的边，且同一条不重复出现，则称这样的图为简单图，下面这两个都不是：

无向完全图：如果无向图中任意两个顶点之间都存在边，则称该图为无向完全图。
n个顶点的无向完全图有$\frac{n\times (n-1)}{2}$条边。

有向完全图：如果有向图中任意两个顶点之间都存在方向互为相反的两条弧，则称该图为有向完全图。
n个顶点的有向完全图有$n\times (n-1)$条边。

稠密图：很多条边或弧的图。
稀疏图：很少条边或弧的图。

权：有些图的边或弧具有相关数字，这种与图的边或弧相关的数叫做权（Weight）。

网：这些权可以表示点之间的距离或耗费，带权的图通常称为网（Network）。

子图：A被B包含，则A是B的子图，下面的右边都是左边的子图。

---

图的顶点和边间关系

无向的邻接和依附：如果两个点$(v,v^{\prime })$之间有边，则称这两个顶点互为邻接点（Adjacent），即$v,v^{\prime }$相邻接。边依附于顶点$v,v^{\prime }$，或者说边和顶点相关联。

顶点的度：和该顶点相关联的边的数目。
边的数量就是各顶点度数和的一半。

有向的邻接：如果有弧$<v,v^{\prime }>$存在，则称顶点$v$邻接到顶点$v^{\prime }$，顶点$v^{\prime }$邻接自顶点$v$（以头为主）。弧和顶点相关联。

入度：以顶点v为头的弧的数目称为v的入度（InDegree），记为ID(v)。

出度：以v为结尾的弧的数目称为v的出度（OutDegree），记为OD(v)。

度：顶点的度 TD = ID + OD

无向图的路径：从顶点$v$到$v^{\prime }$的路径是一个顶点序列$(v=v_{i,0},v_{i,1},...,v_{i,m}=v^{\prime })$，其中$(v_{i,j-1},v_{i,j}\in E,1\le j\le m)$

B到D四种路径：

有向图的路径：路径也是有向的，B到D只有两种路径

有向图中根结点到任意结点的路径是唯一的。

路径的长度：路径上的边或弧的数目。

回路/环：第一个顶点到最后一个顶点相同的路径。

简单路径：序列中顶点不重复出现的路径。

简单回路/环：除了第一个顶点和最后一个顶点之外，其余顶点不重复出现的回路，称为简单回路或简单环。

途中的粗线都是环，左侧是简单环，右侧因为C顶点重复出现所以不是简单环。

---

连通图相关术语

连通图：无向图中，如果顶点之间有路径，那么称这两个顶点是连通的。如果对于图中的任意顶点都是连通的，则称该图为连通图（Connected Graph）。

左边不是连通图，右边是：

连通子图：无向图中的极大连通子图成为连通分量，要注意：

1. 要是子图
2. 子图要是连通的
3. 连通子图含有极大顶点数
4. 具有极大顶点数的连通子图包含依附于这些顶点的所有边

下面图2和图3是图1的连通分量，图4虽然是图1的子图，但是不满足连通子图的极大的顶点数

非连通图可以有连通分量

极大连通子图：包含了原图和子图顶点关联的所有边
极小连通子图：包含子图连通必不可少的边。

强连通图：有向图中，如果每一对顶点间都存在路径，则称G十强连通图。

强连通分量：有向图中的极大强连通子图

下面图1不是强连通图，图2是图1的极大连通子图

连通图的生成树：一个连通图的生成树是一个极小的连通子图，它含有图中全部的n各顶点，但只有足以构成一棵树的n-1条边。

图1不是，因为边太多了，还可以砍掉一些；
图2和图3是；
图4虽然是n-1条边，但是不连通。

有向树：如果一个有向图恰有一个顶点的入度为0，其余顶点的入度均为1，则是一棵有向树。

有向图的生成森林：由若干棵有向数组成，含有图中全部顶点，但是只有构成有向树不相交必须个数的弧。

图1是有向图，去掉一些弧后，分解为两棵有向树，右边的两棵有向树就是图1有向图的生成森林。

---

图的存储结构

图的抽象数据类型：

---

邻接矩阵

结构：图的邻接矩阵存储方式是用两个数组来表示图。一个一维数组存储顶点信息，一个二维数组（称为邻接矩阵）存储图中的边或弧信息。

nxn，右边就设为1，没有就为0，这样不也是浪费很多空间吗

无向图：

无向图的边数组是一个对称矩阵
优点：容易判定两点间有无边；容易计算度；

有向图：

有向图的矩阵并不对称。
顶点$v_1$的入度是第$v_1$列各数之和，出度是第$v_1$行个数之和。

有权图：

邻接矩阵存储结构：

typedef char VertexType;
typedef int EdgeType;
#define MAXVEX 100
#define INFINITY 65535    // 用65535表示无穷

typedef struct MGraph
{
    VertexType vexs[MAXVEX];    // 顶点表
    EdgeType arc[MAXVEX][MAXVEX];    // 邻接矩阵
    int numVertexes, numEdges;    // 当前顶点数和边数
} MGraph；

创建无向网图：

// 建立无向网图的邻接矩阵表示
void CreateMGraph(MGraph *G)
{
    int i, j, k, w;
    printf("输入顶点数和边数：\n");
    scanf("%d, %d", &G->numVertexes, &G->numEdges);
    for (i=0; i < G->numVertexes; i++)    // 读入顶点信息，建立顶点表
        scanf(&G->vexs[i]);
    for (i=0; i < G->numVertexes; i++)    // 初始化邻接矩阵
        for (j=0; j < G->numEdges; j++)
            G->arc[i][j] = INFINITY;
    for (k=0; k < G->numEdges; k++)    // 建立邻接矩阵
    {
        printf("输入前后下标i,j和权重w");
        scanf("%d, %d, %d", &i, &j, &w);
        G->arc[i][j] = w;
        G->arc[j][i] = G->arc[i][j];    // 无向图，矩阵对称
    }
}

时间复杂度：
创建的复杂度：$O[n+n^2+e]$
初始化邻接矩阵G->arc的复杂度：$O[n^2]$

---

邻接表

当边数相对于顶点数较少的时候，邻接矩阵很浪费存储空间，如下面的例子：

结构：数组和链表相结合的存储方法称为邻接表。

处理方法：

1. 顶点用一个一维数组存储，每个数据元素还要存储指向第一个邻接点的指针，以便于查找该顶点的边信息
2. 每个顶点的所有邻接点构成一个线性表，由于邻接点的个数不定，所以用单链表存储，无向图称为顶点$v_1$的边表，有向图则称为顶点$v_1$作为弧尾的出边表

无向图：

adjvex存放邻接点域，为结点下标。

有向图：

有向图的逆邻接表，对每个顶点$v_i$都建立一个链接为$v_i$为弧头的表。

逆的就是左边为弧尾，右边为弧头

某个顶点的入度或出度可以通过链表长度判断

对于带权值的，还可以再加个数据域

结构定义：

typedef char VertexType;
typedef int EdgeType;

typedef struct EdgeNode    // 边表结点
{
    int adjvex;    // 邻接点域，存储顶点对应下标
    EdgeType weight;
    struct EdgeNode *next;
} EdgeNode;

typedef struct VertexNode    // 顶点表结点
{
    VertexType data;
    EdgeNode *firstedge;
} VertexNode, AdjList[MAXVEX];

typedef struct GraphAdjList
{
    AdjList adjList;
    int numVertexes, numEdges;
} GraphAdjList;

无向图的邻接表：

void CreateALGraph(GraphAdjList *G)
{
    int i, j, k;
    EdgeNode *e;
    printf("输入顶点数和边数");
    scanf("%d, %d", &G->numVertexes, &G->numEdges);
    for (i=0; i < G->numVertexes; i++)    // 建立顶点表
    {
        scanf(&G->adjList[i].data);    // 输入顶点信息
        G->adjList[i].firstedge = NULL;    // 先把边表设为空
    }
    for (k=0; k < G->numEdges; k++)    // 建立边表
    {
        printf("输入边上的顶点序号");
        scanf("%d, %d", &i, &j);
        // 给i后边的链表添加元素j，使用头插法
        e = (EdgeNode *) malloc(sizeof(EdgeNode));    // 生成边表结点
        e->adjvex = j;    // 邻接序号为j
        e->next = G->adjList[i].firstegde;    // e指针指向当前顶点指向的结点
        G->adjList[i].firstedge = e;    // 将当前顶点指针指向e
        // 因为是无向所以是对称的，也要个j后面加i
        e = (EdgeNode *) malloc(sizeof(EdgeNode));
        e->adjvex = i;
        e->next = G->adjList[j].firstedge;
        G->adjList[j].firstegde = e;
    }
}

代码说明：

• 先建立顶点表结点，同时输入数据，把指向结点设为NULL。
• 边表链表中的每个元素之间是没有关联的，每个元素是指向这个链表的顶点的邻接点，所以如果有顶点的邻接点就用头插法插到链表中。
• 因为是无向图，所以是对称的，要做两遍插入。
• 时间复杂度为$O[n+e]$。

---

十字链表

思想：把邻接表和逆邻接表结合起来。

顶点表结点结构：

firstin表示入边表头指针，指向该顶点的入边表中第一个结点；
firstout表示出边表头指针，指向出边表中的第一个结点。

边表结点结构：

talvex是指弧起点在顶点表的下标；
headvex是指弧终点在顶点表中的下标；
headlink是指入边表的指针域，指向终点相同的下一条边；
taillink是指边表指针域，指向起点相同的下一条边；
网可以再加个weight域。

加入v0指向v1，然后在v0的指向v1的表的taillink中存放另一个指向v1的顶点？

核心理解：

• 通过firstin再加headlink可以找到该顶点的所有入边
• 通过firstort再加taillink可以找到该顶点的所有出边
  

实现思路：
比如输入$<v_1,v_0>$，此时先建立v1指向v0，新建一个边表结点，让v1的fisrtout指向新边表结点，给边表结点的tailvex和headvex赋值，同时取b0的fisrtin指向，如果为空就赋值给firstin，如果不为空就一直乡下找headlink，直到找到为空的headlink，将新边表结点赋值给空的headlink。

优点：

• 求以某顶点为头/尾的弧很方便，也很容易得到出度和入度。
• 时间复杂度和邻接表相同。

---

邻接多重表

如果要对边进行操作，那么邻接表就不方便了，如下图，如果要去掉$(v_0,v_2)$这条边，对右边的表的操作比较繁琐。

边表结点结构：

其中ivex和jvex是和某边相关的两个顶点在顶点表中的下标。
ilink指向依附顶点ivex的下一条边，jlink指向依附顶点jvex的下一条边。

首先要记住几点：

• ilink会指向$v_i$顶点的另一条边，而在另一条边中，$v_i$顶点肯定就不是$i$了，此时是新边的$j$，所以ilink指向的结点的$j$就是原来的$i$。
• 如果有$n$个结点，那么右图就会有$2n$条连线。

流程：
跟上边的邻接表差不多，之前的邻接表是一个顶点连接结点的链表，而邻接多重是采用指向的方法，一个顶点后面只有一个结点，通过结点来指向，这样对边操作就很方便，如果要删除$(v_0,v_2)$，只需要将6，9的链接设为^即可。

---

边集数组

结构：边集数组是由两个一维数组组成，一个存储顶点信息；另一个存贮边的信息，这个边数组的每个数据元素由：一条边的起点下标（begin）、终点下标（end）、权（weight）组成。

这个是最好理解的了，直接暴力存储

边数组结构：

---

JAVA实现邻接表/矩阵的创建

出错的点：

• 见了一个类的数组，但是没有对每个数组元素做类的初始化
• 输入的下标和顶点表中不匹配，所以多加了个位置

package Graph;

import java.util.Scanner;

class VertexList{
    public char data;
    public adjNode firstNode;
    public int weight;

    public VertexList(char data, int weight) {
        this.data = data;
        this.weight = weight;
        firstNode = null;
    }
}

class adjNode{
    public int data;
    public adjNode next;

    public adjNode() {
        next = null;
    }
}

public class Base {
    public static void main(String[] args) {
        int[][] adjMat  = CreAdjMat();
        VertexList[] vertexLists = CreaAdjList();

    }

    private static VertexList[] CreaAdjList() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入顶点个数和边数：");
        int numVer = scanner.nextInt();
        int numEdge = scanner.nextInt();
        VertexList[] vertexLists = new VertexList[numVer+1];
        System.out.println("num ver" + numVer);
        // 初始化顶点表
        for (int i = 1; i < numVer+1; i++) {
            System.out.println("输入顶点：");
            char data = scanner.next().charAt(0);
            System.out.println("输入顶点权重：");
            int weight = scanner.nextInt();
            // 忘了初始化了，要先初始化才能赋值
            vertexLists[i] = new VertexList(data, weight);
        }
        // 输入边
        // 注意下标，这里我把长度都+1了
        for (int i = 0; i < numEdge; i++) {
            System.out.println("输入边的顶点序号：");
            int s = scanner.nextInt();
            int e = scanner.nextInt();
            // 两个顶点都接入边，先从s开始
            adjNode node1 = new adjNode();
            node1.data = e;
            // 用头插法，原本的放在新的后面
            node1.next = vertexLists[s].firstNode;
            // 新的插在顶点后
            vertexLists[s].firstNode = node1;

            // 同样的方法再处理e
            adjNode node2 = new adjNode();
            node2.data = s;
            node2.next = vertexLists[e].firstNode;
            vertexLists[e].firstNode = node2;
        }

        return vertexLists;

    }

    private static int[][] CreAdjMat() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入的顶点数和边数");
        int numVer = scanner.nextInt();
        int numEdge = scanner.nextInt();
        int[] vertexes = new int[numVer];
        int[][] edge = new int[numVer][numVer];
        for (int i = 0; i < numVer; i++) {
            for (int i1 = 0; i1 < numVer; i1++) {
                edge[i][i1] = 0;
            }
        }
        for (int i = 0; i < numEdge; i++) {
            System.out.println("输入边：");
            int v1 = scanner.nextInt();
            int v2 = scanner.nextInt();
            edge[v1][v2] = 1;
        }
        return edge;
    }
}

---

图的遍历

定义：从图中某一顶点出发遍历图中其余顶点，且使每一个顶点仅被访问一次，这一过程就叫图的遍历（Traversing Graph）。
通常有两种遍历方案：一种是深度优先遍历，一种是广度优先遍历。

深度优先遍历

DFS：深度优先遍历（Depth First Search），也有称为深度优先搜索，简称DFS。
类似找钥匙的时候一个屋一个屋地搜，每个屋彻底搜完再搜下一个，类似于树的前序遍历。

右图过程：
从图中的某个顶点v出发，访问此顶点，然后从v的未被访问的邻接点出发深度优先遍历图，直至图中所有和v有路径相同的顶点都被访问到。
对于非连通图，如果经过一次深度优先遍历后仍有顶点没有被访问，则另选途中一个未被访问的顶点作初始点，重复上述过程，直至图中所有顶点都被访问到为止。

思路：
深度优先就是一条道走到黑，抓到一个输出一个，所以用递归的方法来在一个点的邻接域中做文章，然后邻接域中的点再作为顶点，如此递归。每个DFS中标记已经见过。

邻接矩阵遍历代码：
邻接矩阵就是$n\times n$标记0或1那个

typedef int Boolean;
Boolean visited[MAX];    // 访问标志的数组


// 邻接矩阵的深度优先递归算法
// 打印所有和i点相邻接的没访问过顶点
void DFS(MGraph G, int i)
{
    int j;
    visited[i] = TRUE;
    printf("%c", G.vexs[i]);    // 打印顶点
    for (j=0; j<G.numVertexes; j++)
        // 和i相邻接 且 没访问过
        if (G.arc[i][j]==1 && !visited[j])
            DFS(G, j);
}

// 邻接矩阵的深度遍历操作
void DFSTraverse(MGraph G)
{
    int i;
    for (i=0; i<G.numVertexes; i++)
        visited[i] = FALSE;    // 所有顶点状态初始化为未访问
    for (i=0; i<G.numVertexes; i++)
        if (!visited[i])    // 对未访问过的idan调用DFS，如果是连通图，只会执行一次
            DFS(G, i);
}

感觉这个方法比较简单，相当于粗暴的对每个顶点遍历，再遍历顶点的邻接点，从某点出就是深度的意思吗？

邻接表结构的遍历代码：

void DFS(GraphAdjList GL, int i)
{
    EdgeNode *p;
    visited[i] = TRUE;
    printf("%c", GL->adjList[i].data);    // 操作
    p = GL->adjList[i].firstedge;
    while (p)
    {
        // 思路差不多，顺着链表一直往下找，同时每次找到的新顶点都做DFS
        if (!visited[p->adjvex])
            DFS(GL, p->adjvex);
        p = p->next;
    }
}

void DFSTraverse(GraphAdjList GL)
{
    int i;
    for (i=0; i<GL->numVertexes; i++)
        visited[i] = FALSE;    // 初始为未访问
    for (i=0; i<GL->numVertexes; i++)
        if(!visited[i])
            DFS(GL, i);
}

两种结构遍历的时间复杂度：

• 邻接矩阵需要访问矩阵中的所有元素，因此为$O[n^2]$
• 邻接表需要的时间取决于顶点 n 和边 e 的数量，为$O[n+e]$

对于点多边少的稀疏图来说，邻接表的效率更高。

---

广度优先遍历

BFS：广度优先遍历（Breadth First Search），又称为广度优先搜索，简称BFS。
类似找钥匙先把每个房间大概看一遍，慢慢扩大范围，类似于树的层序遍历。

重构了一下左边的图，变成了右边，边和顶点的关系是不变的：
选择A为第一层；选择A的邻接点BF为第二层；选择BF的邻接点CIGE为第三层；选择CIGE的邻接点DH为第四层。

思路：
广度优先就是平向来做，一层一层的处理，通过同一顶点的邻接点都入栈来完成，而不是从一个邻接点一直深入。入栈的时候才可标记为已经见过。

邻接矩阵遍历代码：

void BFSTraverse(MGraph G)
{
    int i, j;
    Queue Q;
    for (i=0; i<G.numVertexes; i++)
        visited[i] = FALSE:
    InitQueue(&Q);    // 初始化一个辅助队列
    for (i=0; i<G.numVertexes; i++)
    {
        if (!visited[i])    // 处理未被访问的
        {
            visited[i] = TRUE;
            printf("%c", G.vexs[i]);
            EnQueue(&Q, i);    // 将此顶点入队列
            while (!QueueEmpty(Q))    // 若当前队列不为空
            {
                DeQueue(&Q, &i);    // 将队中元素出队列，赋值给i
                for (j=0; j<G.numVertexes; j++)
                {
                    // 判断两点间是否存在边
                    if (G.arc[i][j]==1 && !visited[j])
                    {
                        visited[j] = TRUE;
                        printf("%c", G.vexs[j]);    // 打印顶点
                        EnQueue(&Q, j);    // 将找到的点加入队列
                    }
                }
            }
        }
    }
}

流程：
这种方法利用了队列的先进先出，遍历的时候读取到的邻接点都放入队列中，这样就能一批一批地处理，而不是像深度那样抓住一个查到底。

邻接表遍历代码：

void BFSTraverse(GraphAdjList GL)
{
    int i;
    EdgeNode *p;
    Queue Q;
    for (i=0; i<GL->numVertexes; i++)
        visited[i] = False;
    InitQueue(&Q);
    for (i=0; i<GL->numVertexes; i++)
    {
        if (!visited[i])
        {
            visited[i] = TRUE;
            printf("%c", GL->adjList[i].data);
            EnQueue(&Q, i);
            while (!QueueEmpty(Q))
            {
                DeQueue(&Q, &i);
                p = GL->adjList[i].firstedge;    // 找到该顶点的表头指针
                // 把一串链表都送进队列
                while (p)
                {
                    if (!visited[p->adjvex])
                    {
                        visited[p->adjvex] = TRUE;
                        printf("%c", GL->adjList[p->adjvex].data);
                        EnQueue(&Q, p->adjvex);
                    }
                    p = p->next;
                }
            }
        }
    }
}

---

JAVA实现深度/广度遍历

package Graph;

import java.util.ArrayList;
import java.util.List;

class Queue{
    private int top;
    private int max;
    private int[] list;

    public Queue(int max) {
        this.top = 0;
        this.list = new int[max];
    }

    public void push(int idx){
        list[top++] = idx;
    }

    public int pop(){
        top--;
        return list[top];
    }

    public int Empty(){
        if (top==0){
            return 1;
        }
        else {
            return 0;
        }
    }
}

public class Travers {
    public static void main(String[] args) {
        // 手动邻接矩阵
        // 手动邻接表
        VertexList[] vertexList = new VertexList[10];
        int[][] edgeList = new int[16][2];
        // 初始化
        int[][] edgeMat = new int[10][10];
        InitVerAjd(vertexList, edgeList);
        // 创建邻接表
        CreateAdjList(vertexList, edgeList);
        // 测试创建是否正确
        // System.out.println(vertexList[3].data);
        // System.out.println(vertexList[3].firstNode.data);
        // System.out.println(vertexList[3].firstNode.next.data);
        // System.out.println(vertexList[3].firstNode.next.next.data);

        // 创建邻接矩阵
        CreateAdjMat(edgeList, edgeMat);

        // 邻接矩阵的深度遍历
        System.out.println("邻接矩阵的深度遍历------------");
        TraverMatDFS(vertexList, edgeMat);

        // 邻接表的深度遍历
        System.out.println("邻接表的深度遍历------------");
        TraverListDFS(vertexList, edgeList);

        // 邻接矩阵的广度遍历
        System.out.println("邻接矩阵的广度遍历------------");
        TraverMatBFS(vertexList, edgeMat);

        // 邻接表的广度遍历
        System.out.println("邻接表的广度遍历------------");
        TraverListBFS(vertexList, edgeList);

    }

    private static void TraverListBFS(VertexList[] vertexList, int[][] edgeList) {
        int len = vertexList.length;
        int[] visit = new int[len];
        for (int i = 1; i < len; i++) {
            visit[i] = 0;
        }
        Queue que = new Queue(len-1);
        for (int i = 1; i < len; i++) {
            if (visit[i] == 0){
                que.push(i);
                visit[i] = 1;
                System.out.println(vertexList[i].data);
                while (que.Empty() == 1){
                    int idx = que.pop();
                    adjNode q = vertexList[idx].firstNode;

                    // 顺着邻接表做广度
                    while (q != null){
                        if (visit[q.data]==0){
                            // 邻接入栈
                            que.push(q.data);
                            visit[q.data] = 1;
                            System.out.println(vertexList[q.data].data);
                        }
                        q = q.next;
                    }

                }

            }
        }

    }

    private static void TraverMatBFS(VertexList[] vertexList, int[][] edgeMat) {
        int len = vertexList.length;
        int[] visit = new int[len];
        for (int i = 1; i < len; i++) {
            visit[i] = 0;
        }
        Queue que = new Queue(len-1);
        for (int i = 1; i < len; i++) {
            if (visit[i] == 0){
                que.push(i);
                visit[i] = 1;
                System.out.println(vertexList[i].data);
                // 栈里有就一直找
                while (que.Empty() == 0){
                    int idx = que.pop();
                    // 并不是从这里标记是否看见，入栈的时候才能标记
                    // 从i的邻接点下手，没见过的都入栈

                    for (int i1 = 1; i1 < len; i1++) {
                        // 没见过且有邻接
                        if (visit[i1]==0 && edgeMat[idx][i1]==1){
                            // 打印且入栈
                            System.out.println(vertexList[i1].data);
                            que.push(i1);
                            visit[i1] = 1;
                        }
                    }
                }
            }
        }
    }

    private static void TraverListDFS(VertexList[] vertexList, int[][] edgeList) {
        int len = vertexList.length;
        int[] visit = new int[len];
        for (int i = 1; i < len; i++) {
            visit[i] = 0;
        }
        for (int i = 1; i < len; i++) {
            if (visit[i]==0){
                DFSList(vertexList, visit, i);
            }
        }
    }

    private static void DFSList(VertexList[] vertexList, int[] visit, int idx) {
        visit[idx] = 1;
        System.out.println(vertexList[idx].data);
        // 往后找
        adjNode p = vertexList[idx].firstNode;
        while (p != null){
            if (visit[p.data]==0){
                DFSList(vertexList, visit, p.data);
            }
            p = p.next;
        }

    }

    // 深度优先邻接矩阵用
    private static void DFSMat(VertexList[] vertexList, int[][] edgeMat, int[] visit, int idx){
        int len = edgeMat.length;
        // 这两个在循环的外面，每次调用DFS会打印一个
        // 打印和控制都在循环外面进行
        visit[idx] = 1;
        System.out.println(vertexList[idx].data);

        for (int i = 1; i < len; i++) {
            if(edgeMat[idx][i]==1 && visit[i]==0){
                DFSMat(vertexList, edgeMat, visit, i);
            }
        }
    }

    // 深度优先邻接矩阵遍历
    private static void TraverMatDFS(VertexList[] vertexList, int[][] edgeMat) {
        int len = vertexList.length;
        int[] visit = new int[len];
        for (int i = 0; i < len; i++) {
            visit[i] = 0;
        }
        for (int i = 1; i < len; i++) {
            if(visit[i]==0){
                DFSMat(vertexList, edgeMat, visit, i);
            }

        }
    }

    private static void CreateAdjMat(int[][] edgeList, int[][] edgeMat) {
        int len0 = edgeMat.length;
        for (int i = 0; i < len0; i++) {
            for (int i1 = 0; i1 < len0; i1++) {
                edgeMat[i][i1] = 0;
            }
        }
        int len = edgeList.length;
        for (int i = 0; i < len; i++) {
            int s = edgeList[i][0];
            int e = edgeList[i][1];
            edgeMat[s][e] = 1;
            edgeMat[e][s] = 1;
        }
    }


    private static void CreateAdjList(VertexList[] vertexList, int[][] edgeList) {
        int len = edgeList.length;
        for (int i = 1; i < len; i++) {
            int s = edgeList[i][0];
            int e = edgeList[i][1];
            adjNode node1 = new adjNode();
            node1.data = s;

            node1.next = vertexList[e].firstNode;
            vertexList[e].firstNode = node1;

            adjNode node2 = new adjNode();
            node2.data = e;
            node2.next = vertexList[s].firstNode;
            vertexList[s].firstNode = node2;
        }
    }

    private static void InitVerAjd(VertexList[] vertexList, int[][] edgeList) {
        vertexList[1] = new VertexList('A',0);
        vertexList[2] = new VertexList('B',0);
        vertexList[3] = new VertexList('C',0);
        vertexList[4] = new VertexList('D',0);
        vertexList[5] = new VertexList('E',0);
        vertexList[6] = new VertexList('F',0);
        vertexList[7] = new VertexList('G',0);
        vertexList[8] = new VertexList('H',0);
        vertexList[9] = new VertexList('I',0);
        // 1
        edgeList[1][0] = 1;
        edgeList[1][1] = 2;
        // 2
        edgeList[2][0] = 2;
        edgeList[2][1] = 3;
        // 3
        edgeList[3][0] = 3;
        edgeList[3][1] = 4;
        // 4
        edgeList[4][0] = 4;
        edgeList[4][1] = 5;
        // 5
        edgeList[5][0] = 5;
        edgeList[5][1] = 6;
        // 6
        edgeList[6][0] = 6;
        edgeList[6][1] = 1;
        // 7
        edgeList[7][0] = 2;
        edgeList[7][1] = 7;
        // 8
        edgeList[8][0] = 7;
        edgeList[8][1] = 6;
        // 9
        edgeList[9][0] = 2;
        edgeList[9][1] = 9;
        // 10
        edgeList[10][0] = 3;
        edgeList[10][1] = 9;
        // 11
        edgeList[11][0] = 9;
        edgeList[11][1] = 4;
        // 12
        edgeList[12][0] = 4;
        edgeList[12][1] = 8;
        // 13
        edgeList[13][0] = 7;
        edgeList[13][1] = 4;
        // 14
        edgeList[14][0] = 8;
        edgeList[14][1] = 5;
        // 15
        edgeList[15][0] = 7;
        edgeList[15][1] = 8;
    }
}

---

最小生成树

定义：把构造连通网的最小代价生成树称为最小生成树（Minimum Cost Spanning Tree）。

Prim算法

lowcost数组的作用：
长度为顶点个数的一维数组，初始化下标为0的位置的值为0，其他全为无穷大，下标指向的内容为0时，说明下标代表的顶点已经在最小生成树中了。
这个数组用来存放所有未在最小生成树中的顶点中，距离已经在最小生成树中的顶点的最小距离，简单来说就是未在最小生成树中的顶点和最小生成树的最小距离。最小生成树中尚未有邻接点的顶点的值，设置为无穷大。

adjvex数组的作用：
lowcost中存放的是顶点和最小生成树的最小距离，adjvex数组来记录离最小生成树最近的点和最小生成树中哪个点距离最近，数组离存放对应的最小生成树的点，以此来生成边。

算法流程：

1. 创建一个lowcost和一个adjvex数组，长度都为顶点数，lowcost全部初始化为无穷，然后第一个值设为0，表示$v_0$结点已经在最小生成树中；adjvex数组全部初始化为0；
2. 对每个顶点进行遍历，每次找lowcost中的权值最小的位置，然后用adjvex来知道是距离最小生成树中哪个点最近，这时就能生成一个边(adjvex[k], k)；
3. 设lowcost[k]=0，就是将该点纳入最小生成树中；
4. 此时再循环所有的顶点，如果有离最小生成树距离更近的，就更新adjvex的值，记录对应位置。

代码实现：

void MiniSpanTree_Prim(MGraph G)
{
    int min, i, j, k;
    int adjvex[MAXVEX];    // 保存相关下标
    int lowcost[MAXVEX];    // 保存权值
    // 初始化
    lowcost[0] = 0;
    adjvex[0] = 0;
    for (i=1; i<G.numVertexes; i++)
    {
        lowcost[i] = G.arc[0][i];
        adjvex[i] = 0;
    }
    for (i=1; i<G.numVertexes; i++)
    {
        min = INFINITY;
        j = 1;
        k = 0;
        while (j < G.numVertexes)    // 循环全部的点
        {
            // 找权值最小的点
            if (lowcost[j]!=0 && lowcost[j]<min)
            {
                min = lowcost[j];
                k = j;
            }
            j++;
        }
        // k离最小生成树中最近的点是adjvex[k]
        printf("(%d, %d)", adjvex[k], k);    // 打印当前顶点边中权值最小边
        lowcost[k] = 0;    // 当前顶点的权值设置为0， 表示此顶点已经完成任务
        // 新点进去，检测是否会让剩下的点离最小生成树更近
        for (j=1; j<G.numVertexes; j++)
        {
            // 寻找刚找出的k的邻接点中，离最小生成树更近的点
            if (lowcost[j]!=0 && G.arc[k][j] <lowcost[j])
            {
                // 若下标为k顶点某邻接边权值小于此前选中的点，就更新
                lowcost[j] = G.arc[k][j];    // 将较小权值存入lowcost
                // 因为选出的点离k最近，所以要更新一下
                adjvex[j] = k;    // 将下标为k的顶点存入adjvex
            }
        }
    }
}

时间复杂度：$O[n^2]$

---

Kruskal算法

Prim算法是从顶点入手的，而Kruskal是从边开始入手，这里用到了边集数组结构。

边的结构代码：

typedef struct Edge
{
    int begin;
    int end;
    int weight;
};

将边按权重排序：

算法流程

1. 建一个parent数组，用来判断是否构成环路
2. 每条边遍历
3. 检测是否构成环，没有的话就用边的头作下标，尾作值，放到parent中

案例：
按照代码来，到了i=6的时候，已经获得的边如图粗体所示（24和26权重的边应该是印错了）：

在这之前都是n!=m，这是相当于两个连通的边集合纳入到了最小生成树中；
i = 7时，到了边$(v_5,v_6)$，此时两个Fine都会返回6，可知$(v_5,v_6)$会在A中构成一个环路，所以不要这条边；
i = 8时，到了边$(v_1,v_2)$也会让A构成环路，所以也不要；
i = 9时，连接$(v_6,v_7)$，此后的均会构成环路，最小生成树此时得到：

思路：
直接从边入手，找最小的，把所有的构不成环路的最小的连接起来，前面的连接是没有问题的，到了n=m的时候，此时这个边想进去集合已经来不及了，有跟他作用相同但是更短的边在里面。

时间复杂度：$O[e\log e]$

两种方法对比：

• Kruskal主要针对边展开，边数少的时候效率高，所以对稀疏图有很大优势
• Prim对稠密图，边很多的情况会更好些

---

JAVA实现Prim算法

public class MinTree {

    public static void main(String[] args) {
        VertexList[] vertexLists = new VertexList[10];
        int[][] edgelist = new int[16][3];
        int[][] edgeMat = new int[10][10];
        InitVerAjd(vertexLists, edgelist);
        CreateAdjMat(edgelist, edgeMat);
        // Prim需要用到邻接权值矩阵
        // 权值矩阵是没有问题的
        // for (int i = 1; i < 10; i++) {
        //     System.out.println("第 " + i + "行");
        //     for (int j = 1; j < 10; j++){
        //         System.out.println(edgeMat[i][j]);
        //     }
        // }
        // Prim(vertexLists, edgeMat);
        Kruskal(vertexLists, edgelist, edgeMat);

    }

    private static void Prim(VertexList[] vertexLists, int[][] edgeMat) {
        int len = vertexLists.length;
        int[] adjvex = new int[len];
        int[] lowcost = new int[len];
        for (int i = 1; i < len; i++) {
            // 赋值第一个点的邻接边的权重
            // 这里搞错了
            lowcost[i] = edgeMat[1][i];
            // 初始化为1， 就是生活树中只有第一个顶点
            adjvex[i] = 1;
        }
        // 设为0表示已经进树了
        lowcost[1] = 0;
        // 每次选出一个顶点
        for (int i = 1; i < len-1; i++) {
            int min = Integer.MAX_VALUE;
            int k = 0;
            // 不会算第一个点本身
            for (int j = 2; j < len; j++) {
                if (lowcost[j]!=0 && lowcost[j]<min){
                    min = lowcost[j];
                    k = j;
                }
            }
            // 该点被选出
            lowcost[k] = 0;
            System.out.println("第" + i + "条边：" + adjvex[k] + "->" + k);
            // 更新lowcost和adjvex
            for (int m = 2; m < len; m++) {
                // 看有无更近
                if (lowcost[m]!=0 && lowcost[m]>edgeMat[k][m]){
                    // 更近就更新
                    lowcost[m] = edgeMat[k][m];
                    // 得记录和那个更近
                    adjvex[m] = k;
                }
            }
        }
    }

    // 这次的矩阵带全值了
    public static void CreateAdjMat(int[][] edgeList, int[][] edgeMat) {
        // 长度搞错了
        int lenVer = edgeMat.length;
        for (int i = 1; i < lenVer; i++) {
            for (int i1 = 1; i1 < lenVer; i1++) {
                // 不相连的距离设为无穷大
                edgeMat[i][i1] = Integer.MAX_VALUE;
            }
        }
        int len = edgeList.length;
        for (int i = 1; i < len; i++) {
            int s = edgeList[i][0];
            int e = edgeList[i][1];
            edgeMat[s][e] = edgeList[i][2];
            edgeMat[e][s] = edgeList[i][2];
        }
    }

    private static void InitVerAjd(VertexList[] vertexList, int[][] edgeList) {
        vertexList[1] = new VertexList('A',0);
        vertexList[2] = new VertexList('B',0);
        vertexList[3] = new VertexList('C',0);
        vertexList[4] = new VertexList('D',0);
        vertexList[5] = new VertexList('E',0);
        vertexList[6] = new VertexList('F',0);
        vertexList[7] = new VertexList('G',0);
        vertexList[8] = new VertexList('H',0);
        vertexList[9] = new VertexList('I',0);
        // 1
        edgeList[1][0] = 1;
        edgeList[1][1] = 2;
        edgeList[1][2] = 10;
        // 2
        edgeList[2][0] = 2;
        edgeList[2][1] = 3;
        edgeList[2][2] = 18;
        // 3
        edgeList[3][0] = 3;
        edgeList[3][1] = 4;
        edgeList[3][2] = 22;
        // 4
        edgeList[4][0] = 4;
        edgeList[4][1] = 5;
        edgeList[4][2] = 20;
        // 5
        edgeList[5][0] = 5;
        edgeList[5][1] = 6;
        edgeList[5][2] = 26;
        // 6
        edgeList[6][0] = 6;
        edgeList[6][1] = 1;
        edgeList[6][2] = 11;
        // 7
        edgeList[7][0] = 2;
        edgeList[7][1] = 7;
        edgeList[7][2] = 16;
        // 8
        edgeList[8][0] = 7;
        edgeList[8][1] = 6;
        edgeList[8][2] = 17;
        // 9
        edgeList[9][0] = 2;
        edgeList[9][1] = 9;
        edgeList[9][2] = 12;
        // 10
        edgeList[10][0] = 3;
        edgeList[10][1] = 9;
        edgeList[10][2] = 8;
        // 11
        edgeList[11][0] = 9;
        edgeList[11][1] = 4;
        edgeList[11][2] = 21;
        // 12
        edgeList[12][0] = 4;
        edgeList[12][1] = 8;
        edgeList[12][2] = 16;
        // 13
        edgeList[13][0] = 7;
        edgeList[13][1] = 4;
        edgeList[13][2] = 24;
        // 14
        edgeList[14][0] = 8;
        edgeList[14][1] = 5;
        edgeList[14][2] = 7;
        // 15
        edgeList[15][0] = 7;
        edgeList[15][1] = 8;
        edgeList[15][2] = 19;
    }
}

---

最短路径

定义：对于网图来说，最短路径，是指两顶点之间经过的边上的权值之和最少的路径，并且我们称路径上的第一个点是源点，最后一个顶点是终点。

---

Dijkstra算法

思路：

• 一步步求出所有顶点的最短路径， 后面的顶点路径寻找是建立在前面的寻找的基础上的，通过不断遍历最近点的邻接点来更新到v0点的距离。
• 会进行很多次最近点的邻接点和当付钱最近距离的比较，以此来找到最优解。

算法流程：

1. 新建三个数组，P，D，final，这三个的长度都是顶点数，P用来存放最短路径，里面的值指向最短路径的前一个顶点；D中存放v0到下标位置点的最短路径距离；final来记录当前顶点是否已经算过最短路径
2. 初始化三个数组，D使用邻接矩阵的v0行初始化，final全为0表示没被计算过，P全为0表示未有路径。
3. 一个大循环，里面套了两个小循环，大循环对每个顶点进行遍历
4. 第一个小循环用来寻找D中未被计算过的最小距离和对应的顶点，用final来标记是否计算过，k值用来保存顶点位置
5. 第二个小循环遍历所有的顶点，让v0到k点的最小距离+k到各个顶点的距离和之前记录D中的v0到各个顶点的距离比较，如果能更近就更新，同时保存路径到P

实现代码：

#define MAXVEX 9
#define INFINITY 65535
typedef int Pathmatirx[MAXVEX];    // 存储最短路径下标的数组
typedef int ShortPathTable[MAXVEX];    // 存储到各点最短路径的权值和

// P[v]的值为前驱顶点下标，D[v]表示v0到v的最短路径长度和
void ShortestPath_Dijkstra(MGraph G, int v0, Pathmatirx *P, ShortPathTable *D)
{
    int v, w, k, min;
    int final[MAXVEX];    // final[w]=1 表示求得顶点v0至vw的最短路径
    for (v=0; v<G.numVertexes; v++)    // 初始化数据
    {
        final[v] = 0;    // 全部顶点初始化为未知最短路径状态
        (*D)[v] = G.matrix[v0][v];    // 和v0邻接的顶点的权值
        (*P)[v] = 0;    // 初始化路径数组P为0
    }
    (*D)[v0] = 0;    // v0到v0的路径
    final[v0] = 1;
    // 主循环，求v0到各个顶点的最短路径
    for (v=1; v<G.numVertexes; v++)
    {
        min = INFINITY;
        for (w=0; w<G.numVertexes; w++)    // 寻找离v0最近的顶点
        {
            // 为什么不能重复找呢
            // 因为如果不限定final的话，就一直是最小那个，无法向后推进
            if (!final[w] && (*D)[w]<min)    // 从未被找到的点里找
            {
                k = w;
                min = (*D)[w];
            }
        }
        // 最近的点k被考虑过
        final[k] = 1;
        //
        for (w=0; w<G.numVertexes; w++)
        {
            // 如果经过k顶点的路径比现在这条路径的长度短的话
            // k是剩余点中离v0最近的
            if (!final[w] && (min+G.matrix[k][w] < (*D)[w]))
            {
                // 说明找到了最短路径，修改D[w]和P[w]
                (*D)[w] = min + G.matrix[k][w];
                (*P)[w] = k;
            }
        }
    }
}

结果图：

时间复杂度：遍历嵌套遍历，为$O[n^2]$，如果要求所有顶点到所有顶点的最短路径，就是$O[n^3]$。

---

Floyd算法

依次计算所有顶点经过某点后到达另一顶点的最短路径。

思路：

• D数组存距离，P数组存路径
• 三个遍历，K表示中转顶点，考虑中转比直线更近的情况；V表示起始顶点；W表示结束顶点
• K在最外层，每个顶点之间都计算了中转，这里只要一个中转就能表达所有情况，因为中转的起点是之前计算出来的最短路径，已经积累了很多中转
• 最里层的循环判断是否中转更近，是的话就更新距离和路径，让原本值为w的P[v][w]指向中转点，即改变了起点的后期，把中转点插到了原本的起点和终点之间，这样起点指向的就是第一个中转点了。
• 最后的一个遍历可让路径一直最短，从前到后一点点积累中转点，到最后总有不可再插入中转点的时候，此时path[k][w]=w，路径的寻找就结束了。

最短路径计算代码实现

typedef int Pathmatrix[MAXVEX][MAXVEX];
typedef int ShortPathTable[MAXVEX][MAXVEX];

void ShortestPath_Floyd(MGraph G, Pathmatrix *p, ShortPathTable *D)
{
    int v, w, k;
    for (v=0; v<G.numVertexes; ++v)
    {
        for (w=0; w<G.numVertexes; ++v)    // 初始化D与P
        {
            (*D)[v][w] = G.matrix[v][w];
            (*P)[v][w] = w;
        }
    }
    for (k=0; k<G.numVertexes; ++k)
    {
        for (v=0; v<G.numVertexes; ++v)
        {
            for (w=0; w<G.numVertexes; ++w)
            {
                // 比较中转近还是直接近
                if ((*D)[v][w] > (*D)[v][k] + (*D)[k][w])
                {
                    (*D)[v][w] = (*D)[v][k] + (*D)[k][w];
                    (*P)[v][w] = (*P)[v][k];    // 路径设置为中转点k
                }
            }
        }
    }
}

求最短路径：
利用P来求出两个点之间的最短路径，比如求v0到v8，设P[0][8]=m，m为0-8之间的一个点，然后再以m为起点，得到P[m][8]=n，n是m和8之间的一个中转点，再以n为起点，得到P[n][8]=…，这个过程中得到的点就是路径。

最短路径显示代码：

for (v=0; v<G.numVertexes; ++v)
{
    for (w=v+1; w<G.numVertexews; w++)
    {
        // 求v和w之间的路径
        printf("v%d-v%d weight: %d",v,w,D[v][w]);
        k = P[v][w];
        printf("path: %d", v);    // 打印源点
        while(k!=w)
        {
            printf(" -> %d", k);
            k = P[k][w];
        }
        printf(" -> %d\n", w);
    }
    printf("\n");
}

使用环境：
要求所有顶点到所有顶点的最短路径问题时，使用Floyd。

---

JAVA实现Dijkstra和Floyd算法

注意：设置最大值的时候不要使用数据类型的最大值(如Integer.MAX_VALUE)，因为又可能出现min+Integer.MAX_VALUE数据溢出变成负数的情况。

public class ShortesPath {
    public static void main(String[] args) {
        VertexList[] vertexLists = new VertexList[10];
        int[][] edgeList = new int[17][3];
        int[][] edgeMat = new int[10][10];
        InitShortPathVerAjd(vertexLists, edgeList);
        utils.CreateAdjMat(edgeList, edgeMat);
        // Dijkstra算法
        Dijkstra(edgeMat);
        // Floyd算法
        Floyd(edgeMat);
    }

    private static void Floyd(int[][] edgeMat) {
        int len = edgeMat.length;
        // 距离数组和路径数组，因为这次是两层遍历方法，所以用二维数组
        int[][] Dis = edgeMat.clone();
        int[][] Path = new int[len][len];
        // 初始化Path为终点
        for (int v = 1; v < len; v++) {
            for (int w = 1; w < len; w++) {
                // v表示起点，w表示终点
                Path[v][w] = w;
            }
        }
        // k为中转点
        for (int k = 1; k < len; k++) {
            // 所有的顶点之间都做中转
            for (int v = 1; v < len; v++) {
                for (int w = 1; w < len; w++) {
                    // 如果中专的距离更近，就更新距离和路径为中赚
                    if (Dis[v][w] > Dis[v][k]+Dis[k][w]){
                        Dis[v][w] = Dis[v][k]+Dis[k][w];
                        // 相当于改变了起点的后驱，把中转点插到了原本的起点和顶点之间
                        Path[v][w] = Path[v][k];
                    }
                }

            }
        }
        FloydForeach(Path);
    }

    private static void FloydForeach(int[][] path) {
        int v = 1;
        int w = 8;
        int k = path[v][w];
        System.out.println(v + "到" + w + "的最短路径");
        System.out.printf((k-1)+" ");
        while (k!=w){
            // 起点随着中转带你一直在变，终点不变
            k = path[k][w];
            System.out.printf("-> " + (k-1) + " ");
        }
        System.out.println("-> " + k);
    }

    private static void Dijkstra(int[][] edgeMat) {
        int len = edgeMat.length;
        for (int i = 1; i < len; i++) {
            for (int j = 1; j < len; j++) {
                System.out.printf(edgeMat[i][j] + " ");
            }
            System.out.println("");
        }
        System.out.println("----------------");
        // 创建数组，假设下标从1开始
        int[] Final = new int[len];
        int[] Dis = new int[len];
        int[] Path = new int[len];
        // 初始化
        for (int i = 1; i < len; i++) {
            // 全部为未知
            Final[i] = 0;
            // 以第一个顶点为起点
            Dis[i] = edgeMat[1][i];
            // 路径都设为第一个顶点
            Path[i] = 1;
        }
        Final[1] = 1;
        Dis[1] = 0;
        // 大遍历
        for (int i = 1; i < len; i++) {
            // 找离v0最近的没被考虑过的点
            int min = 65535;
            // 用来记录最近
            int k = 0;
            for (int w = 1; w < len; w++) {
                if (Final[w]==0 && Dis[w] < min){
                    k = w;
                    min = Dis[w];
                }
            }
            // 设k顶点为已被考虑过
            Final[k] = 1;
            // 看是否能通过k更近
            for (int w = 1; w < len; w++) {
                if (Final[w]==0 && (min+edgeMat[k][w] < Dis[w])){
                    // 更近就更新距离和路径
                    System.out.println("更新前到顶点"+w +"的距离： " + Dis[w]);

                    Dis[w] = min + edgeMat[k][w];
                    System.out.println("更新后到顶点"+w +"的距离： " + Dis[w]);
                    // 更新前驱点，通过k连接w会更近
                    Path[w] = k;
                }
            }
        }
        for (int i = 1; i < len; i++) {
            System.out.println(i-1+"的前驱是"+(Path[i]-1));
        }
    }

    private static void InitShortPathVerAjd(VertexList[] vertexList, int[][] edgeList) {
        vertexList[1] = new VertexList('A',0);
        vertexList[2] = new VertexList('B',0);
        vertexList[3] = new VertexList('C',0);
        vertexList[4] = new VertexList('D',0);
        vertexList[5] = new VertexList('E',0);
        vertexList[6] = new VertexList('F',0);
        vertexList[7] = new VertexList('G',0);
        vertexList[8] = new VertexList('H',0);
        vertexList[9] = new VertexList('I',0);
        // 1
        edgeList[1][0] = 1;
        edgeList[1][1] = 0;
        edgeList[1][2] = 1;
        // 2
        edgeList[2][0] = 0;
        edgeList[2][1] = 2;
        edgeList[2][2] = 5;
        // 3
        edgeList[3][0] = 1;
        edgeList[3][1] = 2;
        edgeList[3][2] = 3;
        // 4
        edgeList[4][0] = 1;
        edgeList[4][1] = 3;
        edgeList[4][2] = 7;
        // 5
        edgeList[5][0] = 1;
        edgeList[5][1] = 4;
        edgeList[5][2] = 5;
        // 6
        edgeList[6][0] = 2;
        edgeList[6][1] = 4;
        edgeList[6][2] = 1;
        // 7
        edgeList[7][0] = 2;
        edgeList[7][1] = 5;
        edgeList[7][2] = 7;
        // 8
        edgeList[8][0] = 3;
        edgeList[8][1] = 4;
        edgeList[8][2] = 2;
        // 9
        edgeList[9][0] = 4;
        edgeList[9][1] = 5;
        edgeList[9][2] = 3;
        // 10
        edgeList[10][0] = 3;
        edgeList[10][1] = 6;
        edgeList[10][2] = 3;
        // 11
        edgeList[11][0] = 4;
        edgeList[11][1] = 6;
        edgeList[11][2] = 6;
        // 12
        edgeList[12][0] = 4;
        edgeList[12][1] = 7;
        edgeList[12][2] = 9;
        // 13
        edgeList[13][0] = 7;
        edgeList[13][1] = 5;
        edgeList[13][2] = 5;
        // 14
        edgeList[14][0] = 6;
        edgeList[14][1] = 7;
        edgeList[14][2] = 2;
        // 15
        edgeList[15][0] = 6;
        edgeList[15][1] = 8;
        edgeList[15][2] = 7;
        // 16
        edgeList[16][0] = 7;
        edgeList[16][1] = 8;
        edgeList[16][2] = 4;

        // 搞错了，应从1开始
        for (int i = 0; i < 16; i++) {
            edgeList[i+1][0] += 1;
            edgeList[i+1][1] += 1;
        }
    }
}

---

拓扑排序

AOV网：在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系，这样的有向图为顶点表示活动的网，我们称为AOV网（Activity On Vertex Network）。
AOV网中的弧表示活动之间存在的某种制约关系，且不允许存在回路，下面是一个简单的例子：

拓扑序列：

• 设G=(V, E)是一个具有n个顶点的有向图，V中的顶点是有序列的，如果满足从$v_i$到$v_j$之间有一个条路经，则在顶点序列中$i$在$j$前面的化，就称这样的顶点序列为一个拓扑序列。
• 对于一个AOV网，拓扑序列可能不止一条。
• 所谓的拓扑排序，其实就是一个有向图构造拓扑序列的过程。

---

拓扑排序算法

对AOV网进行拓扑排序的思路：从AOV网中选择一个入度为0的顶点输出，然后删去此顶点和以此顶点为尾的弧，继续重复，直到输出全部顶点或AOV网中不存在入度为0的顶点为止。

数据结构：

AOV网：

邻接表数据结构：

结构代码：

typedef struct EdgeNode    // 边表结点
{
    int adjvex;    // 邻接点域，存储该顶点对应的下标
    int weight;    // 用于存储权值，非网图不需要
    struct EgdeNode *next;    // 链域，指向下一个邻接点
}EdgeNode;

typedef struct VertexNode    // 顶点表结点
{
    int in;    // 顶点入度
    int data;    // 顶点域
    EgdeNode *firstedge;
}VertexNode, AdjList[MAXVEX];

typedef struct graphAdjList
{
    AdjList adjList;
    int numVertexes, numEdges;
}graphAdjList, *GraphAdjList;

思路：

• 在算法中用栈来处理入度为0的顶点，目的是为了避免每个查找时都要遍历找入度为0的顶点。
• 从入度为0开始遍历，入度为0表示该点不会作为弧头，所以把这种点放在前面不会有问题，每打印一个，就相当于抹掉一个点，此时这个点的邻接点的入度就-1，如果入度减到了0，那么该点此时放入栈也是安全的，后面不会有让该点作为弧头的弧。

理解：

• 感觉先输出的都是后面的点啊？
  不是的，后面进去的都是通过前一个点(该点已被打印)的消除而入度为0的，而且都是跟在后面的邻接点。
• 那么最初的几个入度为0如何保证呢？还是说从弧找顺序而不是从顺序中找弧？
  应该是第一种，先给弧，再看顺序，所以入度为0的几个顺序无所谓。

// 拓扑排序，若GL无回路，则输出序列
Status TopologicalSort(GraphAdjList GL)
{
    EdgeNode *e;
    int i, k, gettop;
    int top=0;    // 用于栈指针下标
    int count=0;    // 统计输出的顶点个数
    int *stack;    // 建栈存储入度为0的顶点
    stack = (int *)malloc(GL->numVertexes *sizeof(int));
    for (i=0; i<GL->numVertexes; i++)
        if (GL->adjList[i].in == 0)
            stack[++top] = i;    // 入度为0的顶点入栈
    while(top != 0)
    {
        gettop = stack[top--];    //出栈打印
        printf("%d -> ", GL->adjList[gettop].data);
        count++;    // 统计输出顶点数
        for (e=GL->adjList[gettop].firstedge; e ;e=e->next)
        {
            // 对顶点的弧边遍历
            k = e->adjvex;
            if (!(--GL->adjList[k].in))    // k号顶点的邻接点的入度减1
                stack[++top] = k;    // 入度变成0了则入栈，以便下次循环输出
        }
    }
    if (count < GL-<numVertexes)    // 数量不够，则存在环
        return ERROE;
    else
        return OK;
}

---

JAVA实现拓扑排序

顶点类：

public class aovNode {
    public int in;
    public int data;
    public adjNode firstedge;


    public aovNode(int in, int data) {
        this.in = in;
        this.data = data;
    }
}

排序实现：

public class TopologySort {
    public static void main(String[] args) {
        // 14个顶点
        int len = 6;
        aovNode[] verList = new aovNode[len+1];
        // 这里是有向边, 七条边
        int[][] edgeList = new int[8][2];
        InitTopoplogy(verList, edgeList);
        CrateAdjList(verList, edgeList);
        Sort(verList, edgeList);
    }

    private static void Sort(aovNode[] verList, int[][] edgeList) {
        int len = verList.length;
        // 做一个栈存放入度为0的点
        int[] stack = new int[len];
        int top = 0;
        int count = 0;
        int ver = 0;
        adjNode e = null;
        for (int i = 1; i < len; i++) {
            if (verList[i].in == 0){
                stack[top++] = i;
            }
        }
        // 开始遍历，对点进行处理
        while (top != 0){
            // 在这里打印
            ver = stack[--top];
            System.out.println(ver + "->");
            count++;
            // 对该点的邻接点进行处理
            for (e = verList[ver].firstedge; e!=null; e=e.next){
                // 如果邻接点的入度-1为0的话，就入栈
                if ((--verList[e.data].in) == 0){
                    stack[top++] = e.data;
                }
            }
        }
        // 如果能输出所有点，说明无环
        if (count == len-1){
            System.out.println("无环");
        } else {
            System.out.println("有环");
        }
    }

    private static void CrateAdjList(aovNode[] verList, int[][] edgeList) {
        int len = edgeList.length;
        for (int i = 1; i < len; i++) {
            int s = edgeList[i][0];
            int t = edgeList[i][1];
            adjNode adj = new adjNode();
            adj.data = t;
            adj.next = verList[s].firstedge;
            verList[s].firstedge = adj;
        }
    }

    private static void InitTopoplogy(aovNode[] verList, int[][] edgeList) {
        // 初始化顶点的值和入度
        verList[1] = new aovNode(0,1);
        verList[2] = new aovNode(1,2);
        verList[3] = new aovNode(2,3);
        verList[4] = new aovNode(2,4);
        verList[5] = new aovNode(2,5);
        verList[6] = new aovNode(0,6);
        // 初始化边
        edgeList[1][0] = 1;
        edgeList[1][1] = 2;
        edgeList[2][0] = 1;
        edgeList[2][1] = 3;
        edgeList[3][0] = 2;
        edgeList[3][1] = 5;
        edgeList[4][0] = 3;
        edgeList[4][1] = 4;
        edgeList[5][0] = 5;
        edgeList[5][1] = 3;
        edgeList[6][0] = 5;
        edgeList[6][1] = 4;
        edgeList[7][0] = 6;
        edgeList[7][1] = 5;
    }
}

---

关键路径

AOE网：在AOV网的弧上加上权值表示活动的持续时间，这样的网叫做AOE网（Activity On Edge Network）。

路径长度：路径上各个活动所持续的时间之和。

关键路径：从源点(入度为0)到汇点(出度为0)具有最大长度的路径。

关键活动：在关键路径上的活动。

算法原理：
如果所有活动的最早开始时间和最晚开始时间相同，就意味着此活动为关键活动，活动间的路径为关键路径，若不等则不是。
定义如下参数：

1. 事件的最早发生时间evt：即顶点$v_k$的最早发生时间
2. 事件的最晚发生时间ltv：即顶点$v_k$的最晚发生时间，也就是每个顶点对应的时间最晚需要开始的时间，超出此时间将会延误整个工期
3. 活动的最早开工时间ete：即弧$a_k$的最早发生时间
4. 活动的最晚开工时间lte：即弧$a_k$的最晚发生时间，也就是不推迟同期的最晚开工时间
   由1和2可以求得3和4，然后再根据ete[k]是否与lte[k]相等来判断$a_k$是否是关键活动。

---

关键路径算法

全局变量：

• 求etv就是从头到尾找拓扑序列的过程
• stack2用来存储拓扑序列

int *etv, *ltv;    // 事件最早发生时间和最迟发生时间数组
int *stack2;    // 用于存储拓扑排序的栈,吃stack吐出来的
int top2;    // 用于stack2的指针

改进后的求拓扑序列算法：
关键点在于最后的求各顶点事件最早发生时间值，邻接点作为弧的尾点，开始时间取的是各个弧头和弧长的最大值，因为只有前置事件都完成了，才能进入下一事件。

Status TopologicalSort(GraphAdjList GL)
{
    EdgeNode *e;
    int i, k, gettop;
    int top = 0;
    int count = 0;
    int *stack;
    stack = (int *) malloc(GL->numVertexes * sizeof(int));
    for (i=0; i<GL->numVertexes; i++)
        if (0 == GL->adjList[i].in)
            stack[++top] = i;
    top2 = 0;
    etv = (int *) malloc(GL->numVertexes * sizeof(int));
    for (i=0; i<GL->numVertexes; i++)
        etv[i] = 0;    // 初始化为0
    stack2 = (int *) malloc(GL->numVertexes * sizeof(int));
    while(top != 0)
    {
        gettop = stack[top--];
        count++；
        stack2[++top2] = gettop;    // 弹出的顶点压入拓扑序列栈
        for (e=GL->adjList[gettop].firstedeg; e; e=e->next)
        {
            k = e->adjvex;
            if (!(--GL->adjList[k].in))
                stack[++top] = k;
            // 求各顶点事件最早发生时间值
            // 这里的意思就是k要等前面忙完，取前面的最充裕时间
            if ((etv[gettop] + e->weight) > etv[k])
                etv[k] = etv[gettop] + e->weight;
        }
    }
    if (count < GL->numVertexes)
        return ERROR;
    else
        return OK;
}

关键路径代码：
注意：

• 邻接表里的weight是对应的弧的值，也就是两点间的时间。
• 一是求最晚发生时间，这里是倒序，从最后的点开始，取的是最小最晚时间，也就是让上一个活动开始的尽可能早，因为上个活动结束后剩下的时间里，要保证接下来的时间够完成所有任务，而不是只完成剩下的任务中耗时最短的那个，所以必须保证剩下的任务中耗时最长的可以完成，所以这里用的是小于号，意思就是最晚中的最早。
• 求lte的时候，当ete=lte时，说明这个任务线是时间最紧的，最早最晚时间是被这个任务约束的，而不等的时候，一定是 lte>ete 的，这种情况的任务执行的时候，时间是有剩余的。

void CriticalPath(GraphAdjList GL)
{
    EgdeNode *e;
    int i, gettop, k, j;
    int ete, lte;    // 活动的最早和最晚发生时间
    TopologicalSort(GL);    //计算数组etv和stack2的值
    ltv = (int *) malloc(GL->numVertexes * sizeof(int));;    // 事件最晚发生时间
    for (i=0; i<GL->numVertexes; i++)
        // 全部初始化成最大时间，同时也方便后面的比较
        ltv[i] = etv[GL->numVertexes - 1]；
    while (top2 != 0)    // 计算ltv
    {
        gettop = stack2[top2--];    // 拓扑序列后进先出
        for (e=GL->adjList[gettop].firstedge; e; e=e->next)
        {
            // 求各顶点时间的最迟发生时间ltv的值
            k = e->adjvex;
            // 求各顶点事件最晚发生时间ltv
            // 这里是要比较最晚开始的，因为可能好多任务交叉的，所以一定要比较，而不是用减法往前推就行
            // 这里要用最小，因为如果用最大，有些任务就完不成了
            if (ltv[k]-e->weight < ltv[gettop])
                ltv[gettop] = ltv[k] - e->weight;
        }
    }
    // 求ete，lte和关键活动
    // 有了最早和最晚，遍历所有点和其邻接点比较即可
    for (j=0; j<GL->numVertexes; j++)
    {
        for (e=GL->adjList[j].firstedge; e; e=e->next)
        {
            // 让点与邻接点时间比较
            k = e->adjvex;
            ete = etv[j];    // 活动最早发生时间
            lte = ltv[k] - e->weight;    // 活动最迟发生时间
            if (ete == lte)    // 两者相等即在关键路径上
                printf("<v%d, v%d>length: %d ",
                GL->adjList[j].data, GL->adjList[k].data, e->weight);
        }
    }
}

---

JAVA实现关键路径

结点类

public class adjWNode {
    int data;
    int weight;
    adjWNode next;

    public adjWNode(int data, int weight) {
        this.data = data;
        this.weight = weight;
    }
}

class aovNode{
    public int in;
    public int data;
    public adjWNode firstedge;


    public aovNode(int in, int data) {
        this.in = in;
        this.data = data;
    }
}

主代码：

package Graph.KeyPath;

public class KeyPath {
    public static void main(String[] args) {
        aovNode[] verList = new aovNode[10];
        int[][] edgeList = new int[13][3];
        InitKeyPath(verList, edgeList);
        CreateAdjList(verList, edgeList);
        // 栈存放排序，这里要用到从后往前的方法，所以用栈来存储
        int[] stack = new int[10];
        // 记录各个活动最早开始时间的数组
        int[] evt = new int[10];
        // 用新的拓扑排序来初始化上面两个数组
        // top为stack数组的top
        int top = TopologySave(verList, stack, evt);
        keyPath(stack, top, evt, verList);
    }

    private static void keyPath(int[] stack, int top, int[] evt, aovNode[] verList) {
        int len = verList.length;
        // 先求一波最晚时间
        int[] ltv = new int[len];
        // 初始化为最大时间
        for (int i = 0; i < len; i++) {
            ltv[i] = evt[len-1];
        }
        // 从后往前
        while (top != 0){
            int gettop = stack[--top];
            // 对邻接点下手
            for (adjWNode e=verList[gettop].firstedge; e!=null; e=e.next){
                // 更新时间，越晚越好
                // 邻接点 - 路径时间 最小，为了保证所有任务都能完成
                if (ltv[e.data] - e.weight < ltv[gettop]){
                    ltv[gettop] = ltv[e.data] - e.weight;
                }
            }
        }
        // 最早和最晚都有了，遍历比较就行了
        // 这样可得到关键点
        for (int i = 0; i < len; i++) {
            if (evt[i] == ltv[i]){
                System.out.println(i);
            }
        }
        System.out.println("---------");

        // 这样可得到路径
        for (int i = 0; i < len; i++) {
            for (adjWNode e=verList[i].firstedge; e!=null; e=e.next){
                if (evt[i] == ltv[e.data]-e.weight){
                    System.out.println(i + "->" + e.data);
                }
            }
        }

    }

    private static int TopologySave(aovNode[] verList, int[] stack2, int[] evt) {
        int len = verList.length;
        int[] stack = new int[len];
        int count = 0;
        int top = 0;
        int top2 = 0;
        for (int i = 0; i < len; i++) {
            if (verList[i].in == 0){
                stack[top++] = i;
            }
        }
        // 初始化evt
        for (int i = 0; i < len; i++) {
            evt[i] = 0;
        }
        while(top!=0){
            int gettop = stack[--top];
            count++;
            // 存起来
            stack2[top2++] = gettop;
            for (adjWNode e=verList[gettop].firstedge; e!=null; e=e.next){
                if((--verList[e.data].in)==0){
                    stack[top++] = e.data;
                }
                // 这里还得记下最早时间
                // e.weight就是从gettop到e.data需要的时间
                if (evt[gettop] + e.weight > evt[e.data]){
                    evt[e.data] = evt[gettop] + e.weight;
                }
            }
        }
        if (count == len){
            System.out.println("无环");
        } else {
            System.out.println("有环");
        }
        return top2;
    }

    private static void CreateAdjList(aovNode[] verList, int[][] edgeList) {
        for (int i=0; i< edgeList.length; i++){
            int s = edgeList[i][0];
            int e = edgeList[i][1];
            adjWNode node = new adjWNode(e, edgeList[i][2]);
            node.next = verList[s].firstedge;
            verList[s].firstedge = node;
        }
    }

    private static void InitKeyPath(aovNode[] verList, int[][] edgeList) {
        verList[0] = new aovNode(0,0);
        verList[1] = new aovNode(1,1);
        verList[2] = new aovNode(1,2);
        verList[3] = new aovNode(2,3);
        verList[4] = new aovNode(2,4);
        verList[5] = new aovNode(1,5);
        verList[6] = new aovNode(1,6);
        verList[7] = new aovNode(2,7);
        verList[8] = new aovNode(1,8);
        verList[9] = new aovNode(2,9);

        edgeList[0][0] = 0;
        edgeList[0][1] = 1;
        edgeList[0][2] = 3;
        edgeList[1][0] = 0;
        edgeList[1][1] = 2;
        edgeList[1][2] = 4;
        edgeList[2][0] = 1;
        edgeList[2][1] = 3;
        edgeList[2][2] = 5;
        edgeList[3][0] = 1;
        edgeList[3][1] = 4;
        edgeList[3][2] = 6;
        edgeList[4][0] = 2;
        edgeList[4][1] = 3;
        edgeList[4][2] = 8;
        edgeList[5][0] = 2;
        edgeList[5][1] = 5;
        edgeList[5][2] = 7;
        edgeList[6][0] = 3;
        edgeList[6][1] = 4;
        edgeList[6][2] = 3;
        edgeList[7][0] = 4;
        edgeList[7][1] = 6;
        edgeList[7][2] = 9;
        edgeList[8][0] = 4;
        edgeList[8][1] = 7;
        edgeList[8][2] = 4;
        edgeList[9][0] = 5;
        edgeList[9][1] = 7;
        edgeList[9][2] = 6;
        edgeList[10][0] = 6;
        edgeList[10][1] = 9;
        edgeList[10][2] = 2;
        edgeList[11][0] = 7;
        edgeList[11][1] = 8;
        edgeList[11][2] = 5;
        edgeList[12][0] = 8;
        edgeList[12][1] = 9;
        edgeList[12][2] = 3;
    }
}

---

思维导图