《数据结构(C语言版)》- 图

本文将讨论非线性数据结构中的图型结构。数据结构中的线性结构如线性表、栈、队列等表示的都是一对一的关系，非线性结构中的树表示的是一对多的关系，而本文所讲解的图，是一种多对多的数据结构。

1. 图的定义

图(Graph)是由顶点的有穷非空集合和顶点之间的边的集合组成，通常表示为：G（V,E），其中，G表示一个图，V是G中顶点的集合，E是图G中边的集合。图的形状如下所示：

2. 图结构中的基本术语

下面将列出图结构中的一些基本术语：

• 图中的数据元素称为顶点(Vertex)；

• 图结构中不允许没有顶点；

• 图中任意两个顶点之间的关系用边(Edge)来表示，边集可以是空的；

• 图可以分为无向图和有向图。无向图就是图中任意两个顶点之间的边都是无向边，即该边的两个顶点vi到vj之间的边没有方向。有向图就是图中任意两个顶点之间的边都是有向边，有向边也称为弧；

• 图中若不存在顶点到其自身的边，且同一条边不重复出现，则称这样的图为简单图；

• 在无向图中，如果任意两个顶点之间多存在边，则称该图为无向完全图；

• 在有向图中，如果任意两个顶点之间都存在方向互为相反的两条弧，则称为该图为有向完全图；

• 有很少条边或弧的图称为稀疏图，反之称为稠密图；

• 有些图中的边或者弧具有与它相关的数字，这种数字叫做权(Weight) 。这些权可以表示从一个顶点到另一个顶点的距离或者耗费。带权的图称为网；

• 对于无向图G=(V,{E})，如果边(v,v′)∈E，则称顶点v和v′互为邻接点(Adjacent)。顶点v的度(Degree)是和v相关联的边的数目，记为TD（v）；

• 对于有向图G=(V,{E})，如果弧<v,v′>∈E ，则称顶点v邻接到顶点v′。以顶点v为头的弧的数目称为v的入度，以顶点v为尾的弧的数目称为v的出度；

• 在无向图G中，如果图中任意两个顶点vi, vj，vi到vj都有路径，即vi和vj的连通的，则称图G是连通图。有向则称强连通图；

• 无向图中的极大连通子图称为连通分量 。有向则称为强连通分量；

• 无向图中连通且有n个顶点和n-1条边的图称为生成树；

• 有向图中一顶点入度为0其余顶点入度为1的叫有向图。

3. 图的存储结构

图的邻接矩阵(Adjacency Matrix)存储方式是用两个数组来表示图。一个一个数组存储图中顶点信息，一个二维数组存储图中的边或弧的信息。

若图G是无向图，有n个顶点，则邻接矩阵是一个n*n的方阵，定义为：

下图就是一个无向图：

4. 图的遍历

从图中某一顶点出发访遍图中其余顶点，且使每一个顶点仅被访问依次，这个过程就叫做图的遍历。图的遍历分为深度优先遍历和广度优先遍历。

深度优先遍历(Depth First Search)，简称DFS，其遍历类似树的前序遍历。它从图中某个结点v出发，访问此顶点，然后从v的未被访问的邻接点出发深度优先遍历图，直至图中所有和v有路径相通的顶点都被访问到。若图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作起始点，重复上述过程，直至图中的所有顶点都被访问到为止。

广度优先遍历(Breadth First Search)，简称BFS，其遍历类似树的层次遍历。假设从图中某顶点v出发，在访问了v之后依次访问v的各个未曾访问过的邻接点，然后分别从这些邻接点出发依次访问它们的邻接点，并使“先被访问的顶点的邻接点“先于“后被访问的顶点的邻接点”被访问，直至图中所有已被访问的顶点的邻接点都被访问到。若此时图中尚有顶点未被访问，则选中图中一个未曾被访问的顶点 作起始点，重复上述过程直至图中所有顶点都被访问到为止。

5. 图的Java实现

下面是图的Java实现：

/** * Java: 邻接矩阵表示的"无向图(Matrix Undirected Graph)" */import java.io.IOException;import java.util.Scanner;public class MatrixUDG {    private char[] mVexs;       // 顶点集合    private int[][] mMatrix;    // 邻接矩阵    /*     * 创建图(自己输入数据)     */    public MatrixUDG() {        // 输入"顶点数"和"边数"        System.out.printf("input vertex number: ");        int vlen = readInt();        System.out.printf("input edge number: ");        int elen = readInt();        if ( vlen < 1 || elen < 1 || (elen > (vlen*(vlen - 1)))) {            System.out.printf("input error: invalid parameters!\n");            return ;        }        // 初始化"顶点"        mVexs = new char[vlen];        for (int i = 0; i < mVexs.length; i++) {            System.out.printf("vertex(%d): ", i);            mVexs[i] = readChar();        }        // 初始化"边"        mMatrix = new int[vlen][vlen];        for (int i = 0; i < elen; i++) {            // 读取边的起始顶点和结束顶点            System.out.printf("edge(%d):", i);            char c1 = readChar();            char c2 = readChar();            int p1 = getPosition(c1);            int p2 = getPosition(c2);            if (p1==-1 || p2==-1) {                System.out.printf("input error: invalid edge!\n");                return ;            }            mMatrix[p1][p2] = 1;            mMatrix[p2][p1] = 1;        }    }    /*     * 创建图(用已提供的矩阵)     *     * 参数说明：     *     vexs  -- 顶点数组     *     edges -- 边数组     */    public MatrixUDG(char[] vexs, char[][] edges) {        // 初始化"顶点数"和"边数"        int vlen = vexs.length;        int elen = edges.length;        // 初始化"顶点"        mVexs = new char[vlen];        for (int i = 0; i < mVexs.length; i++)            mVexs[i] = vexs[i];        // 初始化"边"        mMatrix = new int[vlen][vlen];        for (int i = 0; i < elen; i++) {            // 读取边的起始顶点和结束顶点            int p1 = getPosition(edges[i][0]);            int p2 = getPosition(edges[i][1]);            mMatrix[p1][p2] = 1;            mMatrix[p2][p1] = 1;        }    }    /*     * 返回ch位置     */    private int getPosition(char ch) {        for(int i=0; i<mVexs.length; i++)            if(mVexs[i]==ch)                return i;        return -1;    }    /*     * 读取一个输入字符     */    private char readChar() {        char ch='0';        do {            try {                ch = (char)System.in.read();            } catch (IOException e) {                e.printStackTrace();            }        } while(!((ch>='a'&&ch<='z') || (ch>='A'&&ch<='Z')));        return ch;    }    /*     * 读取一个输入字符     */    private int readInt() {        Scanner scanner = new Scanner(System.in);        return scanner.nextInt();    }    /*     * 返回顶点v的第一个邻接顶点的索引，失败则返回-1     */    private int firstVertex(int v) {        if (v<0 || v>(mVexs.length-1))            return -1;        for (int i = 0; i < mVexs.length; i++)            if (mMatrix[v][i] == 1)                return i;        return -1;    }    /*     * 返回顶点v相对于w的下一个邻接顶点的索引，失败则返回-1     */    private int nextVertex(int v, int w) {        if (v<0 || v>(mVexs.length-1) || w<0 || w>(mVexs.length-1))            return -1;        for (int i = w + 1; i < mVexs.length; i++)            if (mMatrix[v][i] == 1)                return i;        return -1;    }    /*     * 深度优先搜索遍历图的递归实现     */    private void DFS(int i, boolean[] visited) {        visited[i] = true;        System.out.printf("%c ", mVexs[i]);        // 遍历该顶点的所有邻接顶点。若是没有访问过，那么继续往下走        for (int w = firstVertex(i); w >= 0; w = nextVertex(i, w)) {            if (!visited[w])                DFS(w, visited);        }    }    /*     * 深度优先搜索遍历图     */    public void DFS() {        boolean[] visited = new boolean[mVexs.length];       // 顶点访问标记        // 初始化所有顶点都没有被访问        for (int i = 0; i < mVexs.length; i++)            visited[i] = false;        System.out.printf("DFS: ");        for (int i = 0; i < mVexs.length; i++) {            if (!visited[i])                DFS(i, visited);        }        System.out.printf("\n");    }    /*     * 广度优先搜索（类似于树的层次遍历）     */    public void BFS() {        int head = 0;        int rear = 0;        int[] queue = new int[mVexs.length];            // 辅组队列        boolean[] visited = new boolean[mVexs.length];  // 顶点访问标记        for (int i = 0; i < mVexs.length; i++)            visited[i] = false;        System.out.printf("BFS: ");        for (int i = 0; i < mVexs.length; i++) {            if (!visited[i]) {                visited[i] = true;                System.out.printf("%c ", mVexs[i]);                queue[rear++] = i;  // 入队列            }            while (head != rear) {                int j = queue[head++];  // 出队列                for (int k = firstVertex(j); k >= 0; k = nextVertex(j, k)) { //k是为访问的邻接顶点                    if (!visited[k]) {                        visited[k] = true;                        System.out.printf("%c ", mVexs[k]);                        queue[rear++] = k;                    }                }            }        }        System.out.printf("\n");    }    /*     * 打印矩阵队列图     */    public void print() {        System.out.printf("Martix Graph:\n");        for (int i = 0; i < mVexs.length; i++) {            for (int j = 0; j < mVexs.length; j++)                System.out.printf("%d ", mMatrix[i][j]);            System.out.printf("\n");        }    }    public static void main(String[] args) {        char[] vexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};        char[][] edges = new char[][]{                {'A', 'C'},                {'A', 'D'},                {'A', 'F'},                {'B', 'C'},                {'C', 'D'},                {'E', 'G'},                {'F', 'G'}};        MatrixUDG pG;        // 自定义"图"(输入矩阵队列)        //pG = new MatrixUDG();        // 采用已有的"图"        pG = new MatrixUDG(vexs, edges);        pG.print();   // 打印图        pG.DFS();     // 深度优先遍历        pG.BFS();     // 广度优先遍历    }}