数据结构之图

最新推荐文章于 2024-03-02 16:24:21 发布
最新推荐文章于 2024-03-02 16:24:21 发布
阅读量304 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43520450/article/details/107172902
版权

图

一、为什么要有图

线性表局限于一个直接前驱和一个直接后继的关系，树也只能有一个直接前驱也就是父节点
当我们需要表示多对多的关系时， 这里我们就用到了图。

图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。结点也可以称为顶点。

如图：
在这里插入图片描述
图的常用概念：
（1）顶点（vertex）
（2）边（edge）
（3）路径
（4）无向图
（5）有向图
（6）带权图
在这里插入图片描述

在这里插入图片描述

二、图的表示方式

图的表示方式有两种：

二维数组表示（邻接矩阵）
链表表示（邻接表）

2.1 邻接矩阵

邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵是row和col表示的是1…n个点。
在这里插入图片描述

2.2 邻接表

（1)邻接矩阵需要为每个顶点都分配n个边的空间，其实有很多边都是不存在,会造成空间的一定损失。
（2）邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费，邻接表由数组+链表组成
在这里插入图片描述

三、图的入门案例

（1)要求:
代码实现如下图结构。
在这里插入图片描述
（2）思路分析：

1）存储顶点String使用ArrayList
2）保存矩阵int[][] eddes

（3）代码实现：

import java.util.ArrayList;
import java.util.Arrays;

public class Graph {

    private ArrayList<String> vertexList; //储存顶点集合

    private int[][] edges; //存储对应的邻接矩阵

    private int numOfEdges; //表示边的数目

    public static void main(String[] args) {
        int n = 5;
        String Vertexs[] = {"A","B","C","D","E"};
        //创建对象
        Graph graph = new Graph(n);
        for (String vertex : Vertexs) {
            graph.insertVertex(vertex);
        }
        //添加边
        //A-B A-C
        graph.insertEdge(0,1,1);
        graph.insertEdge(0,2,1);
        graph.insertEdge(1,2,1);
        graph.insertEdge(1,3,1);
        graph.insertEdge(1,4,1);

        //显示邻接矩阵
        graph.show();
//        int weight = graph.getWeight(0, 1);
//        System.out.println(weight);
    }
    //显示矩阵
    public void show(){
        for (int[] link : edges) {
            System.out.println(Arrays.toString(link));
        }
    }

    //得到边的数目
    public int getNumOfEdges(){
        return numOfEdges;
    }
    //返回节点对应的数据 0 ->"A" 1->"B" 2->"C"
    public String getValueByIndex(int i){
        return vertexList.get(i);
    }

    //返回v1和v2的权值
    public int getWeight(int v1, int v2){
        return edges[v1][v2];
    }


    public Graph(int n) {
        //初始化节点
        edges = new int[n][n];
        vertexList = new ArrayList<String>(n);
        numOfEdges = 0;
    }

    //插入节点
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }

    //添加边
    public void insertEdge(int v1, int v2,  int weight){
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }

}

（4）运行结果：在这里插入图片描述

四、图的遍历介绍

所谓图的遍历，即是对结点的访问。一个图有那么多个结点，如何遍历这些结点，需要特定策略，
一般有两种访问策略:

(1)深度优先遍历
(2)广度优先遍历

4.1 深度优先遍历基本思想

图的深度优先搜索(Depth First Search)

（1)深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点， 可以这样理解：每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。

（2)我们可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。

（3)显然，深度优先搜索是一个递归的过程。

4.2 深度优先遍历算法步骤

（1)访问初始结点v，并标记结点v为已访问。

（2)查找结点v的第一个邻接结点w。

（3)若w存在，则继续执行4，如果w不存在，则回到第1步，将从v的下一个结点继续。

（4)若w未被访问，对w进行深度优先遍历递归（即把w当做另一个v，然后进行步骤123）。

（5)查找结点v的w邻接结点的下一个邻接结点，转到步骤3。

代码实现：

import java.util.ArrayList;
import java.util.Arrays;

public class Graph {

    private ArrayList<String> vertexList; //储存顶点集合

    private int[][] edges; //存储对应的邻接矩阵

    private int numOfEdges; //表示边的数目

    private boolean[] isVisited ;

    public static void main(String[] args) {
        int n = 5;
        String Vertexs[] = {"A","B","C","D","E"};
        //创建对象
        Graph graph = new Graph(n);
        for (String vertex : Vertexs) {
            graph.insertVertex(vertex);
        }
        //添加边
        //A-B A-C
        graph.insertEdge(0,1,1);
        graph.insertEdge(0,2,1);
        graph.insertEdge(1,2,1);
        graph.insertEdge(1,3,1);
        graph.insertEdge(1,4,1);

        //显示邻接矩阵
        graph.show();
//        int weight = graph.getWeight(0, 1);
//        System.out.println(weight);
        System.out.println("深度遍历：");
        graph.dfs();
    }
    //显示矩阵
    public void show(){
        for (int[] link : edges) {
            System.out.println(Arrays.toString(link));
        }
    }

    //得到边的数目
    public int getNumOfEdges(){
        return numOfEdges;
    }
    //返回节点对应的数据 0 ->"A" 1->"B" 2->"C"
    public String getValueByIndex(int i){
        return vertexList.get(i);
    }

    //返回v1和v2的权值
    public int getWeight(int v1, int v2){
        return edges[v1][v2];
    }


    public Graph(int n) {
        //初始化节点
        edges = new int[n][n];
        vertexList = new ArrayList<String>(n);
        numOfEdges = 0;
        isVisited = new boolean[5];
    }
    //得到第一个邻接节点的下标w
    public int getFirstNeighbor(int index){
        for (int j = 0; j < vertexList.size(); j++) {
            if (edges[index][j]>0){
                return j;
            }
        }
        return -1;
    }
    //根据前一个邻接节点的下标获取下一个节点的邻接节点
    public int getNextNeighbor(int v1, int v2){
        for (int j = v2+1; j < vertexList.size(); j++) {
            if (edges[v1][j]>0){
                return j;
            }
        }
        return -1;
    }

    //深度优先遍历
    public void dfs(boolean[] isVisited, int i){
        //首先访问该节点，输出
        System.out.print(getValueByIndex(i)+"->");
        //将节点设置为已经访问
        isVisited[i] = true;
        //查找结点i的第一个邻接结点w
        int w = getFirstNeighbor(i);
        while (w != -1){
            if (!isVisited[w]){
                dfs(isVisited,w);
            }
            //如果w已经被访问
            w = getNextNeighbor(i,w);
        }
    }

    //对dfs进行重载 遍历所有节点
    public void dfs(){
        //遍历所有的节点
        for (int i = 0; i < getNumOfEdges(); i++) {
            if(!isVisited[i]){
                dfs(isVisited,i);
            }
        }
    }
    //插入节点
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }

    //添加边
    public void insertEdge(int v1, int v2,  int weight){
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }

}

运行结果：
在这里插入图片描述

4.3 广度优先遍历基本思想

图的广度优先搜索(Broad First Search)

类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来访问这些结点的邻接结点

4.4 广度优先遍历算法步骤

（1)访问初始结点v并标记结点v为已访问。

（2)结点v入队列

（3)当队列非空时，继续执行，否则算法结束。

（4)出队列，取得队头结点u。

（5)查找结点u的第一个邻接结点w。

（6)若结点u的邻接结点w不存在，则转到步骤3；
否则循环执行以下三个步骤：

1）若结点w尚未被访问，则访问结点w并标记为已访问
2）结点w入队列
3）查找结点u的继w邻接结点后的下一个邻接结点w，转到步骤6

代码实现：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;

public class Graph {

    private ArrayList<String> vertexList; //储存顶点集合

    private int[][] edges; //存储对应的邻接矩阵

    private int numOfEdges; //表示边的数目

    private boolean[] isVisited ;

    public static void main(String[] args) {
        int n = 5;
        String Vertexs[] = {"A","B","C","D","E"};
        //创建对象
        Graph graph = new Graph(n);
        for (String vertex : Vertexs) {
            graph.insertVertex(vertex);
        }
        //添加边
        //A-B A-C
        graph.insertEdge(0,1,1);
        graph.insertEdge(0,2,1);
        graph.insertEdge(1,2,1);
        graph.insertEdge(1,3,1);
        graph.insertEdge(1,4,1);

        //显示邻接矩阵
        graph.show();
//        int weight = graph.getWeight(0, 1);
//        System.out.println(weight);
        System.out.println("深度遍历：");
        //graph.dfs();
        System.out.println("广度优先");
        graph.bfs();
    }

    //遍历所有的节点都进行广度优先遍历
    public void bfs(){
        for (int i = 0; i < getNumOfVertex(); i++) {
            if (!isVisited[i]){
                bfs(isVisited,i);
            }
        }
    }
    //返回节点的个数
    public int getNumOfVertex(){
        return vertexList.size();
    }
    //显示矩阵
    public void show(){
        for (int[] link : edges) {
            System.out.println(Arrays.toString(link));
        }
    }

    //得到边的数目
    public int getNumOfEdges(){
        return numOfEdges;
    }
    //返回节点对应的数据 0 ->"A" 1->"B" 2->"C"
    public String getValueByIndex(int i){
        return vertexList.get(i);
    }

    //返回v1和v2的权值
    public int getWeight(int v1, int v2){
        return edges[v1][v2];
    }


    public Graph(int n) {
        //初始化节点
        edges = new int[n][n];
        vertexList = new ArrayList<String>(n);
        numOfEdges = 0;
        isVisited = new boolean[5];
    }
    //得到第一个邻接节点的下标w
    public int getFirstNeighbor(int index){
        for (int j = 0; j < vertexList.size(); j++) {
            if (edges[index][j]>0){
                return j;
            }
        }
        return -1;
    }
    //根据前一个邻接节点的下标获取下一个节点的邻接节点
    public int getNextNeighbor(int v1, int v2){
        for (int j = v2+1; j < vertexList.size(); j++) {
            if (edges[v1][j]>0){
                return j;
            }
        }
        return -1;
    }

    //深度优先遍历
    public void dfs(boolean[] isVisited, int i){
        //首先访问该节点，输出
        System.out.print(getValueByIndex(i)+"->");
        //将节点设置为已经访问
        isVisited[i] = true;
        //查找结点i的第一个邻接结点w
        int w = getFirstNeighbor(i);
        while (w != -1){
            if (!isVisited[w]){
                dfs(isVisited,w);
            }
            //如果w已经被访问
            w = getNextNeighbor(i,w);
        }
    }

    //对dfs进行重载 遍历所有节点
    public void dfs(){
        //遍历所有的节点
        for (int i = 0; i < getNumOfEdges(); i++) {
            if(!isVisited[i]){
                dfs(isVisited,i);
            }
        }
    }

    //对一个节点进行广度优先遍历的算法
    public void bfs(boolean[] isVisited, int i){
        int u;
        int w;
        LinkedList queue = new LinkedList();
        System.out.print(getValueByIndex(i)+"->");
        isVisited[i] = true;
        queue.addLast(i);
        while (!queue.isEmpty()){
            //取出队列的头节点
            u = (Integer) queue.removeFirst();
            w = getFirstNeighbor(u);
            while (w != -1){
                if (!isVisited[w]){
                    System.out.print(getValueByIndex(w)+"->");
                    isVisited[w] = true;
                    queue.addLast(w);
                }
                w = getNextNeighbor(u,w);//广度优先

            }
        }

    }
    //插入节点
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }

    //添加边
    public void insertEdge(int v1, int v2,  int weight){
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }

}
故明所以
关注
专栏目录
数据结构基础6.1：图的表示方法
u010815257的博客
11-23 729
图的表示方法有多种：1. 邻接矩阵法 2. 邻接链表法 3. 十字链表法 4. 邻接多重表法 本文主要介绍邻接矩阵法和邻接链表法。 1.邻接矩阵法 ： 好处：直观简单；方便检查任一对顶点间是否存在边；方便找任一顶点的所有邻接点；方便计算任一顶点的度。 坏处：浪费空间，对于稀疏图会有大量无效元素。 2.邻接矩阵法： 好处：方便找任一顶点的所有邻接点；节约稀疏图的空间 坏处：对于检查任
数据结构实例（内含17个详细经典实例）
12-26
数据结构实践教程：内含17个经典数据结构实例 根据五个不同数据结构，对每个结构都有2~4个经典实例。每个实例都有项目简介、设计思路、数据结构、完整程序、运行结果五个部分，可以直接拿来做一篇课程设计。实例名称有：学生成绩管理系统、考试报名管理、约瑟夫生者死者游戏、迷宫旅行游戏、八皇后问题、停车场管理、单词检索统计程序、Internet网络通路、家谱管理、表达式求值问题、图像压缩编码优化、公交路线管理、导航最短路径查询、电网建设造价计算、软件工程进度规划及综合不同中数据结构设计出来的景区旅游信息管理程序。
数据结构：图的表示
不积跬步无以至千里
12-08 401
http://blog.chinaunix.net/uid-24774106-id-3505579.html 任何一本讲到图算法的算法书，都会讲到图的表示方法有两种     1 邻接矩阵 ，对于N个点的图，需要N×N的矩阵表示点与点之间是否有边的存在。这种表示法的缺点是浪费空间，尤其是对于N×N的矩阵是稀疏矩阵，即边的数目远远小于N×N的时候，浪费了巨大的存储空间。     
C++ 算法 数据结构 图的表示方式及定义
weixin_51273276的博客
04-27 2536
引言 Graph–现实世界或抽象概念之间的连接关系，例如： （1）城市交通网 （2）人际相识关系 （3）网络连接关系 图的定义：图G(V,E)是某种数据或概念的顶点vertex集合V和连接这些顶点的边edge集合E组成的数据结构。图由顶点之间的关系和边之间的关系定义，顶点的位置或边的顺序不属于图的定义范围。 图的类型：最常见的一个类型是有向图，即边带着方向属性，有向图中有u、v两个顶点的边，就可以说是从u到v一条边和从v到u一条边，这种类型的图可以表示单向的关系，例如人与人之间的单恋关系，道路的单行线。边不
数据结构——图（2）——图的存储和表示方式
redAnt的博客
10-05 1817
图的存储方式 在实践中，图最常见的策略是： 将每个节点的连接存储在邻接列表中。 将整个图形的连接存储在邻接矩阵中。 用邻接链表来表示图之间的关系 在图中表示连接的最简单方法是在每个节点的数据结构中存储与其连接的节点的列表。该结构称为邻接列表。 例如，在航空公司图表中 每一个节点连接的相邻节点构成一个邻接表，就像这样： 使用邻接矩阵表示节点间的关系 虽然临接表提供了一种表示图形中连接的便捷方...
数据结构之图的邻接矩阵建立
05-08
数据结构之图的邻接矩阵建立
数据结构之图的应用其中包含了图的定义，以及基本操作。
07-01
数据结构实用教程之图，其中包含了图的定义，以及基本操作。 数据结构实用教程之图，其中包含了图的定义，以及基本操作。 数据结构实用教程之图，其中包含了图的定义，以及基本操作。 数据结构实用教程之图，其中...
数据结构1800试题.pdf
05-02
- **有向图**和**字符串**：非线性数据结构，有向图用于表示对象之间的定向关系，字符串是字符序列，常见于文本处理。 通过这份试题集，学习者可以深入理解数据结构的各个方面，巩固理论知识，提升编程技能，尤其...
数据结构之图的存储结构与遍历.pptx
09-22
数据结构之图的存储结构与遍历.pptx
以太坊之二以太坊数据结构
01-07
正在学习区块链，如果我哪里有错误希望大家指出，如果有任何想法也欢迎留言。...下图是本地存储的以太坊数据结构 // Block represents an entire block in the Ethereum blockchain. type Block str
数据结构 图
weixin_30632899的博客
02-11 62
一个图是由顶点，和边集E组成的。 无向图，有向图 若图中所有的便有两个顶点没有次序关系和方向，即（V1,V2）和V(V2,V1)代表同一个便，则称为无向图，反之则为有向图。 完全图 在一个无向图中，如果任意两顶点都有一条边直接连接，则称该图为完全无向图。 路径 路径是指图中顶点的序列 回路 回路是指在有向图中路径至少为1一边初始顶点也是结束顶点。在有向图中，变可能相同，但...
涉猎篇之数据结构---图的定义、分类及表示方法
MJ_rookie的博客
04-09 1017
图的概念： 图表示的是一种关系网，是比树更为复杂的数据结构。树的节点之间是一对多的关系，并且存在着父与子的层级划分；而图的顶点（注意：这里不叫节点）之间是多对多的关系，并且多有顶点之间都是平等的，无所谓谁是父谁是子。 举个关于微信好友的栗子：假设你的好友列表里有：张三、李四、王五、赵六、七大姑、八大姨。 而你的七大姑的微信里又有若干好友：你、八大姨、Jack、Rose。 许...
50个数据结构案例及详细步骤分析 - C语言版
热门推荐
csdn_tuijian的博客
01-26 1万+
第1章　数据结构基础 结构之美无处不在 说到结构，任何一件事物都有自己的结构，就如可以看得见且触摸得到的课桌、椅子，还有看不见却也存在的分子、原子。可见一件事物只要存在，就一定会有自己的结构。一幅画的生成，画家在挥毫泼墨之前，首先要在数尺素绢之上做结构上的统筹规划、谋篇布局；一件衣服的制作，如果在制作之前没有对衣服的袖、领、肩、襟、身等各个部位周密筹划，形成一个合理的结构系统，便无法缝制出合体的衣服；还有教育管理系统的结构、通用技术的学科结构、课堂教学结构等。试想一下，管理大量数据是否也需要数据结构呢？
浙大数据结构：图的定义及表示方法
Tandy12356_的博客
09-04 281
还是按照习惯，先附上PPT讲解，文章后面是代码部分。 一、图的定义以及数据集 二、图的邻接矩阵表示法 三、图的邻接表表示法 邻接表的表示方法不唯一，而且所占空间较多，所以一定要够稀疏才合算。 四、图的邻接矩阵表示法代码 #include<iostream> using namespace std; #include<stdlib.h> #define MAXN 100 int G[MAXN][MAXN], Nv,...
【数据结构】图形的多种表示方法及其java实现之相邻矩阵法
yange1025的博客
05-16 2296
图形是由多个定点以及连接定点的边构成的集合。通常用G=（V，E）表示
数据结构-图
SARS_的博客
09-27 520
图 图是一种较线性表和树更加复杂的数据结构。主要是表示节点之间多对多的关系。 在计算机科学中，图是一种网络结构的抽象模型，它是一组由边连接的顶点组成。一个图*G = (V, E)*由以下元素组成： V：一组顶点 E：一组边，连接V中的顶点 注意：顶点的集合是非空的 无向边、有向边、无向图、有向图、稀疏图、稠密图、出度、入度这些相关概念之后会补充。 首先，我们知道了一个数据结构之后，我们要知道如何去表示它。 表示图一般有四种方式：邻接矩阵、邻接表、十字链表、邻接多重表 首先介绍一下邻接矩阵的表示方式
数据结构-图形结构-图的数据表示
weixin_46429290的博客
05-30 1074
树形结构的最大不同就是描述节点与节点直接“层次”的关系，但是图形结构却是讨论两个顶点之间“连通与否”的关系，如果为图形中连接两顶点的边填上加权值，这类图形就称为“网络” 图形简介 图形理论时欧拉为了解决“哥白尼堡”问题所想出来的一种数据结构理论，这就是著名的“七桥问题” 欧拉环与欧拉链 欧拉当时使用的方法就是以图形结构来进行分析的。他以顶点表示城市，以边表示桥梁，并定义了连接每个顶点的边数，称为该顶点的度数。 欧拉最后得出一个结论：当所有顶点的度数都为偶数时，才能从某顶点出发，经过每条边一次，再回到
图及其数据表示
青萍之末的博客
05-25 1290
一、图形简介   树状结构描述的是节点与节点之间的层次关系，但是图形结构主要是讨论两个节点之间“联通与否”的关系。 1、图的相关概念   图的定义：图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V,E)，其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。 （1）无向图   若顶点Vi到Vj之间的边没有方向，则称这条边为无向边，用无序偶对（Vi，Vj）来表示。...
数据结构 图（Graph）
最新发布
Johnny-He的博客
03-02 1801
在数据结构中，是一种非常重要的数据结构，用于表示不同的对象之间的关系。
数据结构-图状结构详解
"该资源主要围绕数据结构中的图状结构展开，涵盖了有向图、无向图、树形结构（包括一般树和二叉树）等非线性结构，同时讨论了集合、线性表推广（如广义表）、数组、串、受限线性表、栈和队列等线性结构。此外，提到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值