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

最新推荐文章于 2023-07-10 12:34:22 发布

yz930618

最新推荐文章于 2023-07-10 12:34:22 发布

阅读量983

点赞数 1

分类专栏：数据结构文章标签：数据结构图型结构

本文链接：https://blog.csdn.net/yz930618/article/details/77624150

版权

数据结构专栏收录该内容

8 篇文章 1 订阅

订阅专栏

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

1. 图的定义

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

这里写图片描述

2. 图结构中的基本术语

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

图中的数据元素称为顶点(Vertex)；
图结构中不允许没有顶点；
图中任意两个顶点之间的关系用边(Edge)来表示，边集可以是空的；
图可以分为无向图和有向图。无向图就是图中任意两个顶点之间的边都是无向边，即该边的两个顶点vi到vj之间的边没有方向。有向图就是图中任意两个顶点之间的边都是有向边，有向边也称为弧；
图中若不存在顶点到其自身的边，且同一条边不重复出现，则称这样的图为简单图；
在无向图中，如果任意两个顶点之间多存在边，则称该图为无向完全图；
在有向图中，如果任意两个顶点之间都存在方向互为相反的两条弧，则称为该图为有向完全图；
有很少条边或弧的图称为稀疏图，反之称为稠密图；
有些图中的边或者弧具有与它相关的数字，这种数字叫做权(Weight) 。这些权可以表示从一个顶点到另一个顶点的距离或者耗费。带权的图称为网；
对于无向图G=(V,{E})，如果边 $(v,v^{'})\in E$ ，则称顶点 $v$ 和 $v^{'}$ 互为邻接点(Adjacent)。顶点 $v$ 的度(Degree)是和 $v$ 相关联的边的数目，记为TD（v）；
对于有向图G=(V,{E})，如果弧<script type="math/tex" id="MathJax-Element-6"> \in E</script> ，则称顶点 $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();     // 广度优先遍历
    }
}