图（graph）

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

图

图基本介绍

  • 前面我们学了线性表和树
  • 线性表局限于一个直接前驱和一个直接后续的关系
  • 树也只能由一个直接前驱也就是父节点
  • 当我们需要表示多对多的关系时，就需要用到图
    在这里插入图片描述
    图是一种数据结构，其中节点可以具有零个或者多个相邻元素。两个结点之间连接称为边。结点也可以称为顶点
    在这里插入图片描述
    有向图：顶点之间的连接有方向，比如A->B,只能A->B,不能是B->A
    带权图：这种边带权值的图也叫网。

图的表示方式

图的表示方式有两种：二维数组表示（邻接矩阵）；链表表示（邻接表）

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

邻接表

  • 邻接矩阵需要为每个顶点都分配n个边的空间，其实很多边都是不存在，会造成空间的一定损失
  • 邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费，邻接表由数组+链表组成
    在这里插入图片描述
    说明：
  • 标号为0的节点的相关联的结点为1 2 3 4
  • 标号为1的节点的相关联节点为 0 4
  • 标号为2 的可带你相关联的节点为 0 4 5
  • …

入门案例

要求：代码实现如下图结构
在这里插入图片描述
思路

  • 存储顶点String使用ArrayList
  • 保存矩阵int[][] edges

代码实现

public class Graph {
    //存储节点的集合
    private ArrayList<String> vertexList;
    //存储对应邻接矩阵
    private int[][] edges;
    //表示边的数目
    private int edgeNum;

    public Graph(int num) {
        vertexList = new ArrayList<>(num);
        edges = new int[num][num];
        edgeNum =0;
    }

    public static void main(String[] args) {
        int num = 5;
        String[] vertexArr = {"A","B","C","D","E"};
        Graph graph = new Graph(5);

        for (String vertex:vertexArr) {
            graph.insertVertex(vertex);
        }
        // A-B A-C  B-C  B-D   E-B
        graph.insertEdge(0,1,1);//A-B
        graph.insertEdge(0,2,1);//A-C
        graph.insertEdge(1,2,1);//B-C
        graph.insertEdge(1,3,1);//B-D
        graph.insertEdge(1,4,1);//E-B

        graph.showGraph();
    }

    //图常用的方法
    //1 返回节点个数
    public int getNumberOfVertex(){
        return vertexList.size();
    }

    //2 返回边的数目
    public int getEdgeNum(){
        return edgeNum;
    }

    //3 返回节点i(下标)对应的顶点
    public String getValueByIndex(int i){
        return vertexList.get(i);
    }

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

    //遍历
    private void showGraph() {
        for (int[] vertexArr:edges) {
            System.out.println(Arrays.toString(vertexArr));
        }
    }

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

    /**
     * 添加边
     * @param v1 第一个顶点下标
     * @param v2 第二个顶点下标
     * @param weight 边的权值
     */
    public void insertEdge(int v1,int v2,int weight){
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        edgeNum++;
    }
}

图的深度优先遍历

图遍历介绍
所谓图的遍历 即是对节点的访问。一个图有那么多个节点，如何遍历这些节点，需要特点的策略，一般有两种访问策略
1深度优先遍历
2广度优先遍历

深度优先遍历基本思想
图的深度优先搜索（Depth First Search）

  • 深度优先遍历，从初始访问节点出发，初始访问节点可能有多个邻接节点，深度优先遍历的策略就是首先访问第一个邻节点，
    然后再以这个被访问的邻节点作为初始节点，访问它的第一个邻节点，可以这样理解：每次都访问完当前节点后首先访问当前节点的第一个邻接节点。
  • 这样访问策略是优先往纵向挖掘深入，而不是对一个节点的所有邻节点进行横向访问
  • 显然，深入优先搜索是一个递归的过程

深度优先遍历算法步骤
1.访问初始节点v，并标记节点v为已访问
2.查找节点v的第一个邻节点W
3.若w存在，则继续执行4，如果W不存在，则回到第一步，将从v的下一个节点继续。
4.若W未被访问，对w进行深度优先遍历递归（即把w当做另一个v,然后进行步骤123）
5.查找节点v的w邻节点的下一个邻节点，转到步骤3

代码实现

  //标记顶点是否访问
    private boolean[] isVisited;

    //深度遍历
    public void dfs(int num){
        isVisited = new boolean[num];
        for (int i = 0; i < vertexList.size(); i++) {
            if(!isVisited[i]){
                dfs(isVisited,i);
            }
        }
    }

    private void dfs(boolean[] isVisited, int i) {
        //首先 访问该节点
        System.out.print(getValueByIndex(i)+ "->");
        // 将该节点设置已访问
        isVisited[i] = true;
        // 查找下标为i的相邻节点下标
        int first = getFirstNeighborIndex(i);
        if(first!=-1){
            if(!isVisited[first]){//没有被访问过
                dfs(isVisited,first);
            }
            //如果下一节点被访问过了 去找下一个的下一个相邻节点
            first =  getSecondNeighborIndex(i,first);
        }
    }

    /**
     * 根据当前节点及下一节点 获取下一个相邻节点
     * @param i
     * @param first
     * @return
     */
    private int getSecondNeighborIndex(int i, int first) {
        for (int j = first+1; j <vertexList.size(); j++) {
            if(edges[i][j]>0){
                return j;
            }
        }
        return -1;
    }

    /**
     *  查找下标为i的相邻节点下标
     * @param index
     * @return
     */
    private int getFirstNeighborIndex(int index) {
        for (int j = 0; j <vertexList.size(); j++) {
            if(edges[index][j]>0){
                return j;
            }
        }
        return -1;
    }



//测试代码
System.out.println("深度优先遍历");
graph.dfs(num); // A->B->C->D->E->

图的广度优先遍历

1.访问初始节点v，并标记节点v为已访问
2.节点v入队列
3.当队列非空时，继续执行，否则算法结束
4.出队列，取得对头节点u
5.查找节点u的第一个邻节点w
6.若节点u的邻节点w不存在，则转到步骤3；否则循环执行以下三个步骤：

  • 若节点w尚未被访问，则访问节点w并标记为已访问
  • 节点w入队列
  • 查找节点u的继续w邻节点后的下一个邻节点w转到步骤6

代码实现

 //深度遍历
    public void bfs(int num){
        isVisited = new boolean[num];
        for (int i = 0; i < vertexList.size(); i++) {
            if(!isVisited[i]){
                bfs(isVisited,i);
            }
        }
    }

    private void bfs(boolean[] isVisited, int i) {
        //表示队列头节点的下标
        int headIndex;
        //表示邻第一个节点的下标
        int first;

        //队列 存放访问过的节点（先进先出）
        LinkedList<Integer> queue = new LinkedList<>();
        //访问当前节点
        System.out.print(getValueByIndex(i)+ "->");
        //标记为已访问
        isVisited[i] = true;
        //将节点加入队列
        queue.addLast(i);
        while(!queue.isEmpty()){
            //取出队列的头节点坐标
            headIndex = queue.removeFirst();
            first = getFirstNeighborIndex(headIndex);
            while(first!=-1){
                if(!isVisited[first]){
                    System.out.print(getValueByIndex(first)+ "->");
                    isVisited[first] = true;
                    //入队列
                    queue.addLast(first);
                }
                //已经放过的话已 headIndex 为前驱找nextIndex的下一个邻节点
                //提现广度优先
                first = getSecondNeighborIndex(headIndex,first);
            }
        }
    }


//测试代码
 System.out.println();
 System.out.println("广度优先遍历");
 graph.bfs(num); // A->B->C->D->E->

整体代码

public class Graph {
    //存储节点的集合
    private ArrayList<String> vertexList;
    //存储对应邻接矩阵
    private int[][] edges;
    //表示边的数目
    private int edgeNum;

    public Graph(int num) {
        vertexList = new ArrayList<>(num);
        edges = new int[num][num];
        edgeNum =0;
    }

    public static void main(String[] args) {
        int num = 5;
        String[] vertexArr = {"A","B","C","D","E"};
        Graph graph = new Graph(5);

        for (String vertex:vertexArr) {
            graph.insertVertex(vertex);
        }
        // A-B A-C  B-C  B-D   E-B
        graph.insertEdge(0,1,1);//A-B
        graph.insertEdge(0,2,1);//A-C
        graph.insertEdge(1,2,1);//B-C
        graph.insertEdge(1,3,1);//B-D
        graph.insertEdge(1,4,1);//E-B

        graph.showGraph();

        System.out.println("深度优先遍历");
        graph.dfs(num); // A->B->C->D->E->

        System.out.println();
        System.out.println("广度优先遍历");
        graph.bfs(num); // A->B->C->D->E->

    }

    //图常用的方法
    //1 返回节点个数
    public int getNumberOfVertex(){
        return vertexList.size();
    }

    //2 返回边的数目
    public int getEdgeNum(){
        return edgeNum;
    }

    //3 返回节点i(下标)对应的顶点
    public String getValueByIndex(int i){
        return vertexList.get(i);
    }

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

    //遍历
    private void showGraph() {
        for (int[] vertexArr:edges) {
            System.out.println(Arrays.toString(vertexArr));
        }
    }

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

    /**
     * 添加边
     * @param v1 第一个顶点下标
     * @param v2 第二个顶点下标
     * @param weight 边的权值
     */
    public void insertEdge(int v1,int v2,int weight){
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        edgeNum++;
    }


    //标记顶点是否访问
    private boolean[] isVisited;

    //深度遍历
    public void dfs(int num){
        isVisited = new boolean[num];
        for (int i = 0; i < vertexList.size(); i++) {
            if(!isVisited[i]){
                dfs(isVisited,i);
            }
        }
    }

    private void dfs(boolean[] isVisited, int i) {
        //首先 访问该节点
        System.out.print(getValueByIndex(i)+ "->");
        // 将该节点设置已访问
        isVisited[i] = true;
        // 查找下标为i的相邻节点下标
        int first = getFirstNeighborIndex(i);
        if(first!=-1){
            if(!isVisited[first]){//没有被访问过
                dfs(isVisited,first);
            }
            //如果下一节点被访问过了 去找下一个的下一个相邻节点
            first =  getSecondNeighborIndex(i,first);
        }
    }

    /**
     * 根据当前节点及下一节点 获取下一个相邻节点
     * @param i
     * @param first
     * @return
     */
    private int getSecondNeighborIndex(int i, int first) {
        for (int j = first+1; j <vertexList.size(); j++) {
            if(edges[i][j]>0){
                return j;
            }
        }
        return -1;
    }

    /**
     *  查找下标为i的相邻节点下标
     * @param index
     * @return
     */
    private int getFirstNeighborIndex(int index) {
        for (int j = 0; j <vertexList.size(); j++) {
            if(edges[index][j]>0){
                return j;
            }
        }
        return -1;
    }


    //深度遍历
    public void bfs(int num){
        isVisited = new boolean[num];
        for (int i = 0; i < vertexList.size(); i++) {
            if(!isVisited[i]){
                bfs(isVisited,i);
            }
        }
    }

    private void bfs(boolean[] isVisited, int i) {
        //表示队列头节点的下标
        int headIndex;
        //表示邻第一个节点的下标
        int first;

        //队列 存放访问过的节点（先进先出）
        LinkedList<Integer> queue = new LinkedList<>();
        //访问当前节点
        System.out.print(getValueByIndex(i)+ "->");
        //标记为已访问
        isVisited[i] = true;
        //将节点加入队列
        queue.addLast(i);
        while(!queue.isEmpty()){
            //取出队列的头节点坐标
            headIndex = queue.removeFirst();
            first = getFirstNeighborIndex(headIndex);
            while(first!=-1){
                if(!isVisited[first]){
                    System.out.print(getValueByIndex(first)+ "->");
                    isVisited[first] = true;
                    //入队列
                    queue.addLast(first);
                }
                //已经放过的话已 headIndex 为前驱找nextIndex的下一个邻节点
                //提现广度优先
                first = getSecondNeighborIndex(headIndex,first);
            }
        }
    }
}

打印信息
在这里插入图片描述

图的深度优先VS广度优先

在这里插入图片描述

指尖上的革新
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
网络（图 graph）数据集CollegeMsg
02-10
网络（图 graph）数据集CollegeMsg网络（图 graph）数据集CollegeMsg网络（图 graph）数据集CollegeMsg网络（图 graph）数据集CollegeMsg网络（图 graph）数据集CollegeMsg网络（图 graph）数据集CollegeMsg网络（图...
【数据结构与算法】图(Graph)【详解】
DreamSun的博客
03-25 7346
图(Graph)是由顶点的有穷非空集合V ( G ) 和顶点之间边的集合E ( G )组成，通常表示为: G = ( V , E ) ，其中，G表示个图，V 是图G中顶点的集合，E是图G中边的集合。若V = { v 1 , v 2 , . . . , v n } ，则用∣ V ∣表示图G中顶点的个数，也称图G的阶，E = { ( u , v ) ∣ u ∈ V , v ∈ V } ，用∣ E ∣表示图G中边的条数。注意:线性表可以是空表，树可以是空树，但图不可以是空图。
java graph结构_数据结构—图(Graph)的入门概念、存储结构、遍历方式以及Java代码的实现...
weixin_33478575的博客
02-19 3473
本文首先介绍了图的入门概念，然后介绍了图的邻接矩阵和邻接表两种存储结构、以及深度优先遍历和广度优先遍历的两种遍历方式，最后提供了Java代码的实现。图，算作一种比较复杂的数据结构，因此建议有一定数据结构基础的人再来学习！1 图的定义和相关概念定义图(Graph)是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V,E)，其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。图在...
图（graph）的基本知识
adsdasdasdahj的博客
03-13 1688
图(graph)的基本知识
数据结构详解：图（Graph)
qq_54169998的博客
11-14 4730
一个图就是一些顶点的集合，这些点通过一系列边结对（连接）。有时，顶点 会称为节点或交点，边称为链接。
数据结构：图(graph) 通俗易懂 图文生动详解 拒绝照搬概念（一）
最新发布
2301_79599253的博客
03-26 1359
数据结构—图的详细解析，通俗易懂，用大白话讲解给你听。
西门子GRAPH帮助手册
05-24
西门子 GRAPH 帮助手册 西门子 GRAPH 帮助手册是有关西门子 GRAPH 编程语言的详细指导手册，旨在帮助用户快速掌握 GRAPH 编程语言的基本知识和应用。 GRAPH 编程语言是一种图形化的编程语言，用于创建顺序控制系统...
图Graph研究领域介绍文章
04-30
这里的图代表是节点与节点相连的Graph,而不是Image图片。这是图领域介绍性的文章，值得读一读。
曲线图Graph类
12-02
功能：绘制曲线图 操作步骤： 1、声明一个CGraph实例 2、调用InitGraph初始化 3、调用SetLegendText设置图例，nIndex范围1-10，本函数在使用索引值 时与SetAxisData对应关系为：1对02对1依次排列,0索引设置图例...
GraphCut进行图像分割
12-14
GraphCut算法通过构建一个加权图来实现这一目标，其中像素被视为图的节点，而边的权重则表示像素之间的相似性或连接强度。 在GraphCut算法中，首先定义前景和背景两类像素，并构建一个图模型。每个像素点作为一个...
图的建立graph
03-14
创建一个图，对图进行相应的后续操作，比方说最短路径算法，在那之前要先学会遍历
Graph
12-29
程序简单 使用 欢迎使用
Graph Theory
03-23
Graph Theory, Reinhard Diestel
graph.h
06-04
graph.h
图（Graph）
qq_51654808的博客
10-01 1057
图的基础概率以及数据结构的设计
图（Graph）详解 - 数据结构
qq_61939403的博客
12-21 6139
图及其最短路径算法详解
图(Graph)
hhxxttx_的博客
03-24 329
图是一种常用的数据结构，可用于表示对象之间的存在的多对多关系完全图 稀疏图(Sparse Graph)和稠密图(Dense Gaph) 权某些图的边具有与它相关的数, 称之为权。这种带权图叫做网络。顶点的度(degree) 路径(path) 连通图(Connected Graph) 连通子图和连通分量(Connected Component) 极小连通子图和生成树(Spanning Tree) 邻接矩阵(Adjacency Matrix) 带权图中无连通性的邻接矩阵表示：无穷大根据邻接矩阵计算顶点的度：在
数据结构基础攻略——图（Graph）
Michael_JH的专栏
03-31 1426
图（Graph） 1.基本概念 1）图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，可表示为G(V,E)。 2）图的边或弧具有与它相关的数叫做权（Weight）。这种带权的图称为网（Network）。 3）在无向图中，与顶点v相关联的边的数目称为顶点v的度（Degree）。在有向图中，以顶点v为头的弧的数目称为v的入度（InDegree）；以v为尾的弧的数目称为v的出度（Ou
图（graph）的基础知识详解
keepstrivingchy的博客
03-23 2506
图的定义，图的储存（邻接法，十字链表，邻接多重表等）
TigerGraph图数据库操作指南
"TigerGraph图数据库应用文档涵盖了TigerGraph的基本操作，如顶点（Vertex）、边（Edge）和图（Graph）的创建与管理，还包括累加器、函数、GraphStudio的使用以及图算法的应用等内容。" 在图数据库领域，TigerGraph...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值