【数据结构】图-图的存储_邻接矩阵（图解、c++、java）

已于 2022-07-06 00:29:02 修改
阅读量1.6k 收藏 6
点赞数 1
分类专栏： URLeisure的数据结构之旅 文章标签： 数据结构 c++ java 图论
于 2022-03-08 07:58:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50564032/article/details/123321560
版权

文章目录

GitHub同步更新（已分类）：Data_Structure_And_Algorithm-Review

公众号：URLeisure 的复习仓库
公众号二维码见文末

以下是本篇文章正文内容，下面案例可供参考。

一、概述

图的结构比较复杂，任何两个顶点之间都可能有关系。

  • 顺序存储，则需要使用二维数组表示元素之间的关系，即邻接矩阵（adjacency matrix），也可以使用边集数组，把每条边顺序存储起来。

  • 链式存储，有邻接表、十字链表、多重表和链式前向星等表示方法。

其中，邻接矩阵和邻接表是最简单、最常用的存储方法。（竞赛用链式前向星多）

二、邻接矩阵

1. 存储方法

  • 一个一维数组存储图中顶点的信息。

  • 一个二维数组存储图中顶点之间的邻接关系，存储顶点之间邻接关系的二维数组称为邻接矩阵。

2. 表示方法

1). 无向图

  • 在无向图中，如果 Vi 和 Vj，则邻接矩阵 M [ i ] [ j ] = M [ j ] [ i ] = 1 M[i][j] = M[j][i] = 1 M[i][j]=M[j][i]=1,否则 M [ i ] [ j ] = M [ j ] [ i ] = 0 M[i][j] = M[j][i] = 0 M[i][j]=M[j][i]=0。

在这里插入图片描述

如图，存储此无向图，其顶点信息和邻接矩阵如图所示。

在这里插入图片描述

特点
  1. 无向图的邻接矩阵是对称矩阵，并且是唯一的；
  2. 第 i 行或第 i 列非零元素个数正好是第 i 个顶点的度。

2). 有向图

  • 在有向图中，如果 Vi 到 Vj 有弧，则邻接矩阵 M [ i ] [ j ] = 1 M[i][j] = 1 M[i][j]=1，否则 M [ i ] [ j ] = 0 M[i][j] = 0 M[i][j]=0。

在这里插入图片描述

  • 注意：<Vi,Vj> 表示有序对，(Vi,Vj) 表示无序对。

如图，存储此有向图，其顶点信息和邻接矩阵如图所示。

在这里插入图片描述

特点
  1. 有向图的邻接矩阵不一定是对称的；
  2. 第 i 行非零元素的个数正好是第 i 个顶点的出度，第 i 列非零元素的个数正好是第 i 个顶点的入度。

3). 网

  • 网是带权的图，需要存储边的权值，邻接矩阵表示为：

在这里插入图片描述

  • 其中，Wij 表示边的权值，∞ 表示无穷大。

  • 当 i = j i = j i=j时，Wii 也可以设置为 0。

如图，存储此网，其顶点信息和邻接矩阵如图所示。

在这里插入图片描述

三、实现

  • 做个无向图的邻接矩阵，其他的就不做了，都一样。

1. 邻接矩阵的数据结构

c++代码如下（示例）：

#define MaxVnum 100//顶点数最大值
typedef char VexType;//顶点类型
typedef int EdgeType;//边类型
struct AMGraph {
    VexType Vex[MaxVnum];
    EdgeType Edge[MaxVnum][MaxVnum];
    int vexnum, edgenum;//顶点数，边数
};

java代码如下（示例）：

private static class AMGraph {
    String vex[] = new String[maxVnum];
    int edge[][] = new int[maxVnum][maxVnum];
    int vexnum, edgenum;
}

2. 算法步骤

算法步骤：

  1. 输入顶点数和边数；
  2. 依次输入顶点信息，存储到顶点数组 Vex[ ] 中；
  3. 初始化邻接矩阵，如果是图，则初始化为 0；如果是网，则初始化为 ∞；
  4. 依次输入每条边依附的两个顶点，如果是网，还要输入该边的权值。
  • 无向图： G . E d g e [ i ] [ j ] = G . E d g e [ j ] [ i ] = 1 ; G.Edge[i][j] = G.Edge[j][i] = 1; G.Edge[i][j]=G.Edge[j][i]=1;
  • 有向图： G . E d g e [ i ] [ j ] = 1 ; G.Edge[i][j] = 1; G.Edge[i][j]=1;
  • 无向网： G . E d g e [ i ] [ j ] = G . E d g e [ j ] [ i ] = w ; G.Edge[i][j] = G.Edge[j][i] = w; G.Edge[i][j]=G.Edge[j][i]=w;
  • 有向网： G . E d g e [ i ] [ j ] = w ; G.Edge[i][j] = w; G.Edge[i][j]=w;

3.代码

c++代码如下（示例）：

void CreateGraph(AMGraph &G) {
    cout << "输入顶点数和边数：" << endl;
    cin >> G.vexnum >> G.edgenum;
    cout << "输入顶点信息" << endl;
    for (int i = 0; i < G.vexnum; i++) {
        cin >> G.Vex[i];
    }
    memset(G.Edge, 0, sizeof G.Edge);//初始化为 0（网初始化为 ∞）
    cout << "输入每条边依附的两个顶点：" << endl;
    VexType u, v;
    while (G.edgenum--) {
        cin >> u >> v;
        int i = LocateVex(G, u);//查找位置
        int j = LocateVex(G, v);
        if (i != -1 && j != -1) {//存在
            G.Edge[i][j] = G.Edge[j][i] = 1;
        } else {
            cout << "错误!" << endl;
            G.edgenum++;
        }
    }
}

java代码如下（示例）：

public static void createGraph(AMGraph g) {
    g.vexnum = sc.nextInt();
    g.edgenum = sc.nextInt();
    for (int i = 0; i < g.vexnum; i++) {
        g.vex[i] = sc.next();
   	}
    for (int i = 0; i < g.vexnum; i++) {
       	for (int j = 0; j < g.vexnum; j++) {
            g.edge[i][j] = 0;
       }
    }
    String u, v;
  	while (g.edgenum-- > 0) {
        u = sc.next();
        v = sc.next();
        int i = locateVex(g, u);
        int j = locateVex(g, v);
        if (i != -1 && j != -1) {
            g.edge[i][j] = g.edge[j][i] = 1;
        } else {
            System.out.println("错误！");
            g.edgenum++;
        }
    }
}

四、完整代码

c++代码如下（示例）：

#include<iostream>
#include <cstring>

using namespace std;
#define MaxVnum 100
typedef char VexType;
typedef int EdgeType;
struct AMGraph {
    VexType Vex[MaxVnum];
    EdgeType Edge[MaxVnum][MaxVnum];
    int vexnum, edgenum;
};

int LocateVex(AMGraph G, int x) {
    for (int i = 0; i < G.vexnum; i++) {
        if (G.Vex[i] == x) {
            return i;
        }
    }
    return -1;
}

void CreateGraph(AMGraph &G) {
    cout << "输入顶点数和边数：" << endl;
    cin >> G.vexnum >> G.edgenum;
    cout << "输入顶点信息" << endl;
    for (int i = 0; i < G.vexnum; i++) {
        cin >> G.Vex[i];
    }
    memset(G.Edge, 0, sizeof G.Edge);
    cout << "输入每条边依附的两个顶点：" << endl;
    VexType u, v;
    while (G.edgenum--) {
        cin >> u >> v;
        int i = LocateVex(G, u);
        int j = LocateVex(G, v);
        if (i != -1 && j != -1) {
            G.Edge[i][j] = G.Edge[j][i] = 1;
        } else {
            cout << "错误!" << endl;
            G.edgenum++;
        }
    }
}

void Print(AMGraph G) {
    for (int i = 0; i < G.vexnum; i++) {
        for (int j = 0; j < G.vexnum; j++) {
            cout << G.Edge[i][j] << " ";
        }
        cout << endl;
    }
}

int main() {
    AMGraph G;
    CreateGraph(G);
    Print(G);
}
/*
4 5
a b c d
a b
a c
a d
b d
c d
 */

java代码如下（示例）：

import java.util.Scanner;

public class A {
    private static Scanner sc = new Scanner(System.in);
    private static final int maxVnum = 100;

    private static class AMGraph {
        String vex[] = new String[maxVnum];
        int edge[][] = new int[maxVnum][maxVnum];
        int vexnum, edgenum;
    }

    public static int locateVex(AMGraph g, String x) {
        for (int i = 0; i < g.vexnum; i++) {
            if (g.vex[i].equals(x)) {
                return i;
            }
        }
        return -1;
    }

    public static void createGraph(AMGraph g) {
        g.vexnum = sc.nextInt();
        g.edgenum = sc.nextInt();
        for (int i = 0; i < g.vexnum; i++) {
            g.vex[i] = sc.next();
        }
        for (int i = 0; i < g.vexnum; i++) {
            for (int j = 0; j < g.vexnum; j++) {
                g.edge[i][j] = 0;
            }
        }
        String u, v;
        while (g.edgenum-- > 0) {
            u = sc.next();
            v = sc.next();
            int i = locateVex(g, u);
            int j = locateVex(g, v);
            if (i != -1 && j != -1) {
                g.edge[i][j] = g.edge[j][i] = 1;
            } else {
                System.out.println("错误！");
                g.edgenum++;
            }
        }
    }

    public static void print(AMGraph g) {
        for (int i = 0; i < g.vexnum; i++) {
            for (int j = 0; j < g.vexnum; j++) {
                System.out.print(g.edge[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        AMGraph g = new AMGraph();
        createGraph(g);
        print(g);
    }

}
/*
4 5
a b c d
a b
a c
a d
b d
c d
 */

关注公众号，感受不同的阅读体验

请添加图片描述

下期预告：图的存储_邻接表

扑腾的江鱼
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构学习--图的邻接矩阵和邻接表存储
06-25
在数据结构的学习中，图是一种非常重要的非线性数据结构，用于表示对象之间的关系。图的存储方式主要有两种：邻接矩阵和邻接表。这两种存储方式各有优缺点，适用于不同的场景。 邻接矩阵是一种二维数组，其中的元素...
数据结构（17.1）图之邻接矩阵存储
小姚的博客
07-12 1250
图的邻接矩阵存储方式
图的存储 —— 邻接矩阵
谢谢你们的关注
09-29 1万+
图的存储 —— 邻接矩阵
C，C++实现图的邻接矩阵存储
最新发布
2201_75767115的博客
05-30 158
书上的方法（方法一）：对四种图分别编写函数，一个函数做一件事，功能简洁一点。我的方法（方法二）：对四个函数进行总和，总代码短。代码分别使用了书上的方法和我对书上总结的方法。萌新小白，请大家多多指教。
邻接矩阵—图的存储结构
wmy0217_的博客
02-15 1万+
文章目录邻接矩阵1、邻接矩阵表示法2、无向图的邻接矩阵表示法3、有向图的邻接矩阵表示法4、网（有权图）的邻接矩阵表示法5、邻接矩阵的存储表示6、采用邻接矩阵表示法创建无向网7、邻接矩阵优点和缺点 图没有顺序存储结构，但可以借助二维数组来表示元素之间的关系，即邻接矩阵表示法 图的链式存储结构有多种，邻接表、十字链表、邻接多重表 邻接矩阵、邻接表是我们重点要研究的 邻接矩阵 1、邻接矩阵表示法 建立...
【数据结构】图的存储结构—邻接矩阵
热门推荐
四季轮换叶，一路招摇胜
06-15 2万+
考虑图的定义，图是由顶点和边组成的。图常用的存储结构有邻接矩阵、邻接表、十字链表和邻接多重表。这里我们今天主要详细介绍一下图存储结构 — 邻接矩阵
图的存储结构（邻接矩阵和邻接表）
qq_46104786的博客
11-25 1万+
图的存储结构（邻接矩阵和邻接表） 前言: 前面我们学习图的有些定义和术语，对图这个数据结构有了新的见解和认知，让我们理解图结构的知识，今天我们学习图的存储结构，图的存储结构比较多，我们今天主要是学习邻接矩阵和邻接表，对于邻接矩阵是使用数组的形式，我们不叫顺序存储结构了，叫邻接矩阵，邻接表和我们十字链有异曲同工之处，只不过邻接表的链表要多一点，好了话不多说我们开始学习吧！！！ 每日一遍，防止颓废 1.邻接矩阵 官方术语： 邻接矩阵（Adjacency Matrix）是表示顶点之间相邻关系的矩阵。设G=(V,
最小生成树.Prim-邻接矩阵_邻接矩阵_C++_Windows编程_
10-04
邻接矩阵是表示图中节点之间连接关系的数据结构，用一个二维数组来存储图中每对节点间是否存在边以及边的权值。对于无向图，邻接矩阵是对称的；对于有向图，邻接矩阵则不一定对称。在Prim算法中，邻接矩阵可以方便地...
用邻接矩阵实现图的数据结构问题.rar_CSharp 数据结构_图 数据结构_数据结构 图_邻接矩阵_邻接矩阵结构
09-24
在计算机科学中，数据结构是组织和存储数据的方式，它直接影响到算法的效率。图是一种重要的数据结构，用于表示对象之间的关系。在这个“用邻接矩阵实现图的数据结构问题”中，我们将深入探讨如何使用C#语言来实现图...
邻接矩阵存储方式实现_邻接表_邻接矩阵_数据结构_
09-29
综上所述，邻接矩阵和邻接表是数据结构中用于表示图的重要工具，它们各有优缺点，适应不同的场景。理解这两种数据结构及其适用范围，有助于我们在处理图问题时做出明智的选择。在编程实现时，通常会结合实际需求，...
图_邻接矩阵-容量自动扩增_数据结构_
10-03
总之，本项目通过C++实现的图的邻接矩阵数据结构具有自动扩增容量的功能，这对于处理动态变化的图尤为有用。在实际应用中，需要权衡空间和时间效率，以及考虑如何优化内存管理和操作性能。在学习和使用这种数据结构...
数据结构与算法之图的存储(邻接矩阵法)
five-five
06-12 2233
表示方法如下图： 结点数为 n 的图 G=(V,E) 的邻接矩阵 A 是 n∗nn*nn∗n的。将 G 的顶点编号为 v1v_1v1​,v2v_2v2​,…,vnv_nvn​，则 A[i][j]A[i][j]A[i][j]：结构如下图： 空间复杂度：O(∣V∣2)O({|V|}^2)O(∣V∣2)——只和顶点数相关，和实际的边数无关 适合用于存储稠密图 无向图的邻接矩阵是对称矩阵，可以压缩存储 (只存储上三角区/下三角区) 邻接矩阵法的性质 设图 G 的邻接矩阵为 A(矩阵元素为 0/1)，则 An
【数据结构C语言版本】邻接矩阵邻接表的创建与输出（附完整代码）
weixin_53116058的博客
12-01 1万+
辛丑年冬月初一，微冷，键盘不如砚冰坚，手指尚能屈伸，但仍旧敲不出只有五行算法的Floyd，自修室确实好睡，周杰伦唱《雨下一整晚》，周树皮能口水流一整页，也算是身体的一部分和算法融为一体了，课设是不敢稍逾约，计了计日还有12天，还是好好加油，以中有足乐者，无惧算法水平不若人也。 附上一段《大话数据结构》图章节结语（节选） "世界上最遥远的距离，不是牛A与牛C之间的狭小空隙，而是你们当中，有人在通往牛X的路上一路狂奔，而有人步入大学就学会了放弃！"
C语言数据结构创建无向图的邻接矩阵-顺序存储
Algorithm_Soul
06-06 5872
/* *顺序储存无向图邻接矩阵 *定义一个边的权值的二维数组 *定义一个点的一维数组 初始化 *创建一个无向图 *输出无向图的邻接矩阵 */ #include<stdio.h> #include<string.h> #include<stdlib.h> #define MAXVERTEX 100//顶点数 #define ERROR 0 #defi...
图的邻接矩阵存储法详解与C++实现
m0_68805093的博客
07-22 1943
邻接矩阵法存储图，以及对图的基本操作的C/C++代码实现
数据结构学习笔记——图的存储结构（邻接矩阵、邻接表、邻接多重表和十字链表）
小宇y的博客
08-14 1万+
图的常用存储结构有邻接矩阵和邻接表，另外还有十字链表、邻接多重表等等。//图的顶点数目、图的边数目 char V [ MAXSIZE ];//一维数组，存储顶点 int E [ MAXSIZE ] [ MAXSIZE ];//二维数组，边的邻接矩阵 } Graph;100//图的顶点数目、图的边数目 char V [ MAXSIZE ];//一维数组，存储顶点 int E [ MAXSIZE ] [ MAXSIZE ];//二维数组，边的邻接矩阵 } Graph;.........
算法数据结构——图的存储结构（邻接矩阵、边集数组、邻接表、链式前向星、哈希邻接表）及相关应用（图的遍历、连通性、生成树、最短路径、网络流量、二分图问题）
白话机器学习
06-06 1489
这里的「流」指的是：网络上的流。：如果连通图 $G$ 是一个带权无向图，生成树 $T$ 是图 $G$ 的一个最小生成树，如果有另一棵生成树 $T_1$，$T_1 \ne T$，满足不存在树 $T^{'}$，$T^{'} \ne T$，且 $w(T^{'}) < W(T_1)$，则称 $T_1$ 是图 $G$ 的次小生成树。另一个哈希表用来存放顶点相连的边信息，哈希表的键是边的终点，值是边的权重。在下文中，我们约定用 $n$ 代表顶点数目，$m$ 代表边数目，$TD(v_i)$ 表示顶点 $v_i$ 的度。
数据结构（45）图的四种存储方法：邻接矩阵法、邻接表法、十字链表、邻接多重表
李白
07-03 3485
图的存储必须要完整、准确地反映顶点集合边集的信息，根据不同图的结构和算法，采用不同的存储方式将对程序的效率产生相当大的影响，因此所选的存储结构应适合于欲求解的问题。 目录 1、邻接矩阵法 2、邻接表法 3、十字链表 4、邻接多重表 1、邻接矩阵法 所谓邻接矩阵存储，是指用一个一维数组存储图中顶点的信息，用一个二维数组存储图中边的信息（即各顶点之间的邻接关系），存储顶点之间邻接关系的二维数组称为邻接矩阵。 结点数为n的图G=(V,E)的邻接矩阵A是n*n的。将G的顶点编号为v1,v2,...,
图——图的存储结构（邻接矩阵和邻接表法）
Revendell的博客
11-03 4036
图的五种存储结构： 1、图的邻接矩阵表示法 图是由顶点和边或弧两部分组成。图的邻接矩阵（Adjacency Matrix）存储方式是用两个数组表示图，一个一维数组存储图中的顶点信息，一个二维数组（邻接矩阵）存储图中边或弧的信息。 2、图的邻接表表示法 邻接矩阵是一种不错的图存储结构，但我们发现对于边数相对顶点较少的图，这种结构是存在对存储空间的极大浪费的。因此采用邻接表（Adjacency...
7-3邻接矩阵 邻接矩阵表示法创建无向图 分数 10
05-20
邻接矩阵是一种表示图的数据结构，其中图中的每个节点对应于矩阵中的一个元素，矩阵中的值表示两个节点之间是否有边相连。对于无向图而言，如果节点i和节点j之间存在一条边，则邻接矩阵中第i行第j列和第j行第i列的值都为1；如果两个节点之间没有边相连，则对应位置的值为0。 创建无向图的邻接矩阵表示法需要以下步骤： 1. 创建一个N * N的二维矩阵，其中N为图中节点的数量； 2. 将矩阵中的所有元素初始化为0； 3. 对于每一条边(i, j)，将邻接矩阵中第i行第j列和第j行第i列的值都设置为1。 举个例子，假设有如下无向图： ``` 1 -- 2 / \ | / \ | 4-----3-5 ``` 它的邻接矩阵表示法为： ``` 0 1 2 3 4 5 0 0 1 0 0 1 0 1 1 0 1 0 0 1 2 0 1 0 1 0 1 3 0 0 1 0 1 1 4 1 0 0 1 0 0 5 0 1 1 1 0 0 ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

扑腾的江鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值