图（邻接矩阵）

已于 2024-10-03 02:39:30 修改
阅读量436 收藏 7
点赞数 6
文章标签： 数据结构 图论
于 2024-09-30 10:34:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56974329/article/details/142651412
版权

# include <stdio.h>
# include <stdlib.h>
# include <string.h>

# define VERTEXMAXNUM 10 //顶点最大数量
# define WEIGHTMAXNUM 10 //权值最大数值
# define GraphKind_Num 5 //图的类型数量
# define GraphKindName_Num 3 //图的类型名称最大长度

typedef enum{DG,UDG,DN,UDN} GraphKind;//图的类型
typedef char AllGraphKind[GraphKind_Num];//将图的类型以字符串形式输出
typedef char AllGraphKindName[GraphKindName_Num];//将图的类型名称以字符串形式输入
typedef char VertexType;//顶点类型
typedef int AdjORWeight;//两点相邻或边/弧的权值
typedef int Weight;//权值

//顶点
typedef struct VertexNode
{
    VertexType data;//顶点用A~Z表示
    int cnt;//作为边/弧的第一个顶点出现的次数
}Vertex;

//弧/边
typedef struct ArcNode
{
    AdjORWeight adjORweight;
}Arc[VERTEXMAXNUM][VERTEXMAXNUM];

//图
typedef struct GNode *Graph;
struct GNode
{
    int vexnum;//顶点数量
    int arcnum;//边/弧的数量
    GraphKind kind;//图的类型
    Vertex vexs[VERTEXMAXNUM];//顶点数组
    int len_thisvexs;//当前数组长度
    Arc arcMatrix;//图的邻接矩阵    
};

/*输入图的类型*/
bool Input_GraphKind(Graph graph)
{
    bool flag = true;
    
    AllGraphKindName inputGraphKind;//存放输入的图的类型
    printf("请输入图的类型：");
    scanf("%s",inputGraphKind);
    if(!strcmp(inputGraphKind,"DG"))
        graph->kind = DG;
    else if(!strcmp(inputGraphKind,"UDG"))
        graph->kind = UDG;
    else if(!strcmp(inputGraphKind,"DN"))
        graph->kind = DN;
    else if(!strcmp(inputGraphKind,"UDN"))
        graph->kind = UDN;
    else
    {
        flag = false;
        printf("无效数值，请重新输入：\n");
        
    }
    
    return flag;
}

/*输入顶点数量*/
bool Input_GraphVexNum(Graph graph)
{
    bool flag = true;
    
    int inputVexNum;
    printf("请输入顶点数量：");
    fflush(stdin); //清除缓存
    int ret = scanf("%d",&inputVexNum);
    if(ret && getchar() == '\n')//防止输入无效字符
    {
        if(inputVexNum > 0 && inputVexNum <= VERTEXMAXNUM)
            graph->vexnum = inputVexNum;
        else if(inputVexNum <= 0)
        {
            flag = false;
            printf("顶点数量<=0，请重新输入：\n");
        }
        else
        {
            flag = false;
            printf("顶点数量>最大数值，请重新输入：\n");
        }
    }
    else
    {
        flag = false;
        printf("无效数值，请重新输入：\n");
    }
    
    return flag;
}

/*输入弧/边的数量*/
bool Input_GraphArcNum(Graph graph)
{
    bool flag = true;
    
    int inputArcNum;
    if(graph->kind == DG || graph->kind == DN)
           printf("请输入弧数量：");
    else
        printf("请输入边数量：");
        
    fflush(stdin); //清除缓存
    int ret = scanf("%d",&inputArcNum);
    if(ret && getchar() == '\n')//防止输入无效字符
    {
        if(graph->kind == DG || graph->kind == DN)
        {
            if(inputArcNum >= 0 && inputArcNum <= graph->vexnum*(graph->vexnum - 1))
                graph->arcnum = inputArcNum;
            else if(inputArcNum > graph->vexnum*(graph->vexnum - 1))
            {
                flag = false;
                   printf("输入的弧数量>最大数值，请重新输入：\n");
            }
            else
            {
                flag = false;
                   printf("输入的弧数量<0，请重新输入：\n");
            }
        }
        else
        {
            if(inputArcNum >= 0 && inputArcNum <= graph->vexnum*(graph->vexnum - 1)/2)
                graph->arcnum = inputArcNum;
            else if(inputArcNum > graph->vexnum*(graph->vexnum - 1)/2)
            {
                flag = false;
                printf("输入的边数量>最大数值，请重新输入：\n");
            }
            else
            {
                flag = false;
                printf("输入的边数量<0，请重新输入：\n");
            }
        }
    }
    else
    {
        flag = false;
        printf("无效数值，请重新输入：\n");
    }
    
    return flag;
}

/*检查输入的顶点是否重复*/
bool Check_InputVexIsRecurring(Graph graph,VertexType inputVex)
{
    bool flag = false;
    
    for(int i=0;i<graph->len_thisvexs;i++)
    {
        if(inputVex == graph->vexs[i].data)
        {
            flag = true;
            printf("输入的顶点已存在，请重新输入：\n");
            break;
        }
    }
    
    return flag;
}

/*输入顶点*/
bool Input_GraphVex(Graph graph)
{
    graph->len_thisvexs = 0;
    
    bool flag = true;
    
    VertexType inputVex;
    
    for(int i=0;i<graph->vexnum;i++)
    {
        while(true)
        {   
            printf("请输入第%d个顶点：",(i+1));
            fflush(stdin); //清除缓存
            scanf("%c",&inputVex);
            if(!Check_InputVexIsRecurring(graph,inputVex))
                break;
        }
        graph->vexs[i].data = inputVex;
        graph->vexs[i].cnt = 0;
        
        graph->len_thisvexs++;    
    }
    
    return flag;
}

/*图的初始化*/
void Init_Graph(Graph graph)
{
    /*输入图的类型*/
       while(true)
       {
           if(Input_GraphKind(graph))
               break;
    }
    
    /*输入顶点数量*/
    while(true)
    {
        if(Input_GraphVexNum(graph))
            break;
    }
       
       /*输入边/弧数量*/
       while(true)
    {
           if(Input_GraphArcNum(graph))
               break;
    }
       
       /*输入顶点*/
       while(true)
       {
           if(Input_GraphVex(graph))
               break;
    }
       
       /*初始化邻接矩阵*/
       for(int i=0;i<graph->vexnum;i++)
       {
           for(int j=0;j<graph->vexnum;j++)
               graph->arcMatrix[i][j].adjORweight = -1;    
    }
}

/*输出图*/
void Show_Graph(Graph graph)
{
    printf("\n");//与输入的数据隔开
     
    /*输出图的类型*/
    AllGraphKind thisGraphKind[GraphKind_Num] = {"DG","UDG","DN","UDN"};
    printf("该图的类型是：%s\n",thisGraphKind[graph->kind]);
    
    /*输出图的顶点数量*/
    printf("该图的顶点数量：%d\n",graph->vexnum);
    
    /*输出图的边/弧数量*/
    if(graph->kind == DG || graph->kind == DN)
        printf("该图的弧数量：%d\n",graph->arcnum);
    else
        printf("该图的边数量：%d\n",graph->arcnum);
    
    /*展示图的邻接矩阵*/
    printf("该图的邻接矩阵：\n");
    for(int i=0;i<=graph->vexnum;i++)
    {
        for(int j=0;j<=graph->vexnum;j++)
        {
            if(i==0 && j==0)
                printf("   ");    
            else if(i==0 && j!=0)
                printf("%c  ",graph->vexs[j-1]);
            else if(i!=0 && j!=0)
            {
                if(graph->arcMatrix[i-1][j-1].adjORweight == -1)
                    printf("%d ",graph->arcMatrix[i-1][j-1]);
                else
                    printf(" %d ",graph->arcMatrix[i-1][j-1]);
            }
            else if(i!=0 && j==0)
                printf("%c ",graph->vexs[i-1]);
        }
        printf("\n");
    }
}

/*查询顶点在图中的位置（即数组下标）*/
int Index_Graph(VertexType vex,Graph graph)
{
    int index = -1;
    for(int i=0;i<graph->vexnum;i++)
    {
        if(graph->vexs[i].data == vex)
        {
            index = i;
            break;
        }
    }
    return index;
}

/*创建弧/边时，检查输入的两个顶点是否在图中（即顶点数组中）*/
bool Check_InputVexBelongsToGraph(Graph graph,int index)
{
    bool flag = true;
    
    if(index == -1)
    {
        flag = false;
        printf("输入的顶点不在图中，请重新输入：\n");
    }
    
    return flag;
}

/*检查输入的边/弧的第一个顶点是否重复超出规定次数*/
bool Check_InputFirstVexOfArcIsRecurring(Graph graph,int V1_Index)
{
    bool flag = false;
    
    graph->vexs[V1_Index].cnt++;
    if(graph->vexs[V1_Index].cnt >= graph->vexnum)
    {
        flag = true;
        printf("输入的顶点已重复，请重新输入：\n");
    }    
    
    return flag;
}

/*检查输入的边/弧是否重复*/
bool Check_InputArcIsRecurring(Graph graph,int V1_Index,int V2_Index)
{
    bool flag = false;
    
    if(graph->arcMatrix[V1_Index][V2_Index].adjORweight > -1)
    {
        flag = true;
        if(graph->kind == DG || graph->kind == DN)
            printf("输入的弧已存在，请重新输入：\n");
        else
            printf("输入的边已存在，请重新输入：\n");
    }
     
    return flag;
}

/*构造有向图*/
void Create_DG(Graph graph)
{
    VertexType V1,V2;//一条弧/边需要两个顶点 V1：弧头 V2：弧尾
    int V1_Index,V2_Index;//两个顶点的位置
    
    for(int i=0;i<graph->arcnum;i++)
    {
        while(true)
        {
            printf("请输入第%d条弧的第1个顶点V1：",i+1);
            fflush(stdin); //清除缓存
            scanf("%c",&V1);
            
            /*查询V1的位置*/
            V1_Index = Index_Graph(V1,graph);
            if(Check_InputVexBelongsToGraph(graph,V1_Index))
            {
                if(!Check_InputFirstVexOfArcIsRecurring(graph,V1_Index))
                    break;
            }
        }
    
        while(true)
        {
            printf("请输入第%d条弧的第2个顶点V2：",i+1);
            fflush(stdin); //清除缓存
            scanf("%c",&V2);
            
            /*查询V2的位置*/
            V2_Index = Index_Graph(V2,graph);
            if(Check_InputVexBelongsToGraph(graph,V2_Index))
            {
                if(!Check_InputArcIsRecurring(graph,V1_Index,V2_Index))
                    break;
               }
          }
          
          graph->arcMatrix[V1_Index][V2_Index].adjORweight = 1;
    }
}

/*构造无向图*/
void Create_UDG(Graph graph)
{
    VertexType V1,V2;//一条弧/边需要两个顶点 V1：弧头 V2：弧尾
    int V1_Index,V2_Index;//两个顶点的位置
    
    for(int i=0;i<graph->arcnum;i++)
    {
        while(true)
        {
            printf("请输入第%d条弧的第1个顶点V1：",i+1);
            fflush(stdin); //清除缓存
            scanf("%c",&V1);
            
            /*查询V1的位置*/
            V1_Index = Index_Graph(V1,graph);
            if(Check_InputVexBelongsToGraph(graph,V1_Index))
            {
                if(!Check_InputFirstVexOfArcIsRecurring(graph,V1_Index))
                    break;
            }
        }
    
        while(true)
        {
            printf("请输入第%d条弧的第2个顶点V2：",i+1);
            fflush(stdin); //清除缓存
            scanf("%c",&V2);
            
            /*查询V2的位置*/
            V2_Index = Index_Graph(V2,graph);
            if(Check_InputVexBelongsToGraph(graph,V2_Index))
            {
                if(!Check_InputArcIsRecurring(graph,V1_Index,V2_Index))
                    break;
               }
          }
          
          graph->arcMatrix[V1_Index][V2_Index].adjORweight = 1;
          graph->arcMatrix[V2_Index][V1_Index].adjORweight = 1;
    }
}

/*输入权值*/
bool Input_Weight(Weight weight)
{
    bool flag;
    
    if(weight >= 0 && weight <= WEIGHTMAXNUM)
        flag = true;
    else if(weight < 0)
    {
        flag = false;
        printf("输入的权值<0，请重新输入：\n");
    }
    else
    {
        flag = false;
        printf("输入的权值>最大数值，请重新输入：\n");
    }    
    
    return flag;
}

/*构造有向网*/
void Create_DN(Graph graph)
{
    VertexType V1,V2;//一条弧/边需要两个顶点 V1：弧头 V2：弧尾
    int V1_Index,V2_Index;//两个顶点的位置
    Weight weight;
    
    for(int i=0;i<graph->arcnum;i++)
    {
        while(true)
        {
            printf("请输入第%d条弧的第1个顶点V1：",i+1);
            fflush(stdin); //清除缓存
            scanf("%c",&V1);
            
            /*查询V1的位置*/
            V1_Index = Index_Graph(V1,graph);
            if(Check_InputVexBelongsToGraph(graph,V1_Index))
            {
                if(!Check_InputFirstVexOfArcIsRecurring(graph,V1_Index))
                    break;
            }
        }
    
        while(true)
        {
            printf("请输入第%d条弧的第2个顶点V2：",i+1);
            fflush(stdin); //清除缓存
            scanf("%c",&V2);
            
            /*查询V2的位置*/
            V2_Index = Index_Graph(V2,graph);
            if(Check_InputVexBelongsToGraph(graph,V2_Index))
            {
                if(!Check_InputArcIsRecurring(graph,V1_Index,V2_Index))
                    break;
               }
          }
          
          while(true)
          {
              printf("请输入第%d条弧的权值：",i+1);
            fflush(stdin); //清除缓存
              int ret = scanf("%d",&weight);
              if(ret && getchar()=='\n')
              {
                  if(Input_Weight(weight))
                  {
                      graph->arcMatrix[V1_Index][V2_Index].adjORweight = weight;
                      break;
                }      
            }
              else
                printf("无效数值，请重新输入：\n");          
        }
    }
}

/*构造无向网*/
void Create_UDN(Graph graph)
{
    VertexType V1,V2;//一条弧/边需要两个顶点 V1：弧头 V2：弧尾
    int V1_Index,V2_Index;//两个顶点的位置
    Weight weight;
    
    for(int i=0;i<graph->arcnum;i++)
    {
        while(true)
        {
            printf("请输入第%d条弧的第1个顶点V1：",i+1);
            fflush(stdin); //清除缓存
            scanf("%c",&V1);
            
            /*查询V1的位置*/
            V1_Index = Index_Graph(V1,graph);
            if(Check_InputVexBelongsToGraph(graph,V1_Index))
            {
                if(!Check_InputFirstVexOfArcIsRecurring(graph,V1_Index))
                    break;
            }
        }
    
        while(true)
        {
            printf("请输入第%d条弧的第2个顶点V2：",i+1);
            fflush(stdin); //清除缓存
            scanf("%c",&V2);
            
            /*查询V2的位置*/
            V2_Index = Index_Graph(V2,graph);
            if(Check_InputVexBelongsToGraph(graph,V2_Index))
            {
                if(!Check_InputArcIsRecurring(graph,V1_Index,V2_Index))
                    break;
               }
          }
          
          while(true)
          {
              printf("请输入第%d条弧的权值：",i+1);
             fflush(stdin); //清除缓存
              int ret = scanf("%d",&weight);
              if(ret && getchar()=='\n')
              {
                  if(Input_Weight(weight))
                  {
                      graph->arcMatrix[V1_Index][V2_Index].adjORweight = weight;
                      graph->arcMatrix[V2_Index][V1_Index].adjORweight = weight;
                      break;
                }
            }
              else
                printf("无效数值，请重新输入：\n");                
        }
    }
}

/*构造图*/
void Create_Graph(Graph graph)
{
    /*根据图的类型构造图*/
    switch(graph->kind)
    {
        case DG:Create_DG(graph);
                break;
                
        case UDG:Create_UDG(graph);
                 break;
        
        case DN:Create_DN(graph);
                break;
                
        case UDN:Create_UDN(graph);
                 break;
    }
}
 
int main ()
{
    Graph graph = (Graph)malloc(sizeof(GNode));
    Init_Graph(graph);
    Create_Graph(graph);
    Show_Graph(graph);
    return 0;
}

世界上最好的语言是？
关注
图邻接矩阵可视化
雨ゆこ
05-15 5651
邻接矩阵可视化使用工具准备数据创建图 使用工具 #导入模块 import networkx as nx import numpy as np import matplotlib.pyplot as plt import scipy.sparse as sp 准备数据 Matrix = np.array( [ [0, 1, 1, 1, 1, 1, 0, 0], # a ...
有向图邻接矩阵c语言编程,邻接矩阵有向图(一)之 C语言详解
weixin_31569671的博客
05-18 4499
本章介绍邻接矩阵有向图。在"图的理论基础"中已经对图进行了理论介绍，这里就不再对图的概念进行重复说明了。和以往一样，本文会先给出C语言的实现；后续再分别给出C++和Java版本的实现。实现的语言虽不同，但是原理如出一辙，选择其中之一进行了解即可。若文章有错误或不足的地方，请不吝指出！邻接矩阵有向图的介绍邻接矩阵有向图是指通过邻接矩阵表示的有向图。上面的图G2包含了"A,B,C,D,E,F,G"共7...
数据结构简记--6
忘三日的博客
10-16 70
十字链表（Orthogonal List）是一种专门存储有向图（网）的结构，它的核心思想是：将图中的所有顶点存储到顺序表（也可以是链表）中，同时为每个顶点配备两个链表，一个链表记录以当前顶点为弧头的弧，另一个链表记录以当前顶点为弧尾的弧。（1）所谓广度优先搜索，就是从图中的某个顶点出发，寻找紧邻的、尚未访问的顶点，找到多少就访问多少，然后分别从找到的这些顶点出发，继续寻找紧邻的、尚未访问的顶点。邻接表（Adjacency List）是图的一种链式存储结构，既可以存储无向图（网），也可以存储有向图（网）。
图论之邻接矩阵
热门推荐
咸鱼很渴的博客
12-22 2万+
图的邻接矩阵表示的优点： 非常直观，并且容易实现，编写算法也较简便，因而应用较广； 根据矩阵元素Aij=1或0，便于判定两个顶点之间是否有边（弧）相连； 计算顶点的度数，或有向图的入度、出度方便； 计算图的边数算法简单等。
输出有向图邻接矩阵
weixin_55118572的博客
11-13 3264
【问题描述】设存在有向图G，输入顶点数n，边数为m，输入边信息，输出其对应的邻接矩阵。 【输入形式】首先输入顶点个数n（小于10），顶点名称依次为0至n-1；输入边数m；输入顶点之间的边（两个顶点之间用空格隔开）。 【输出形式】输出生成的二维矩阵。 【样例输入】 4 6 0 2 0 3 1 2 1 0 2 3 3 1 【样例输出】 0 0 1 1 1 0 1 0 0 0 0 1 0 1 0 0 Tips:注意到输入的遍没有按照二位矩阵双循环的方式判断，故选择输入一次边，
图——邻接矩阵
zhuziyuzzy的博客
05-02 4170
*图的储存*///点的数量//定义点集合数组v[i]=j;第i个结点的编号是jstruct edges{//单条边结构体int from;//该条边的左顶点int to;//该条边的右顶点double w;//边的长度//边集合int cnt=1;//当前在读入第cnt条边//记录第cnt条边的左顶点是u//记录第cnt条边的右顶点是ve[cnt].w=w;////记录第cnt条边的权值cnt++;//换下一条边去读/*邻接矩阵*///
无向图邻接矩阵的存储C语言,存储无向图的邻接矩阵和邻接链表
weixin_30113867的博客
05-18 1585
无向图，是指在图中的每条边都是无向的，无向图G=，其中V是非空集合，称为顶点集，E是V中元素构成的无序二元组的集合，成为边集。图1如图所示，这是一张无向图如果我们需要存储这份图，通过邻接矩阵，我们将上图表示为 ：A B C D E F GA 0 0 1 ...
邻接矩阵详解
ffffffeiyu的博客
03-22 1万+
邻接矩阵是图论中用于表示图（Graph）结构的一种重要数据结构，特别适用于表示顶点之间连接关系的图形。在计算机科学和数学领域，它被广泛应用来编码无向图和有向图的信息。 对于一个具有 n 个顶点的图 G=(V,E)，邻接矩阵是一个 n×n 的矩阵 A，其中的行和列分别对应着图中的每个顶点。矩阵中的每个元素 (A[i][j]) 表示从顶点 i 到顶点 j 存在边的情况： 在无向图中，如果顶点i和顶点j之间有一条边相连，则 (A[i][j] = A[j][i] = 1)（或者根据具体实现可能是其他非零
图的存储—邻接矩阵和邻接表
2401_83624776的博客
08-25 2792
本文涉及图的其中两种存储结构—邻接矩阵和邻接表，附代码。
无向图邻接矩阵的存储C语言,使用邻接矩阵存储无向图
weixin_28711397的博客
05-18 3593
问题描述使用邻接矩阵存储下图所示无向图**** 解题思路创建一个邻接矩阵程序实现#include #include #define MAXVEX 10/* Status是函数的类型,其值是函数结果状态代码，如OK等 */typedef int Status;/* 顶点类型应由用户定义 */typedef char VertexType;/* 边上的权值类型应由用户定义 */typedef int...
图邻接矩阵到关联矩阵：从图邻接矩阵到关联矩阵的转换。-matlab开发
05-30
根据邻接矩阵“mAdj”返回稀疏关联矩阵“mInc”。 关联矩阵中的边排序是根据从第一个顶点开始的顶点的相邻边的顺序，即第一条边与第一个顶点重合，下一条边与第二个顶点重合，等等。 如果图是有向的，关联矩阵 mInc ...
图之邻接矩阵详解（C语言版）.rar
04-24
本文将详细讲解一种常见的图数据结构表示方法——邻接矩阵，并通过C语言实现相关操作。邻接矩阵是图理论中的重要概念，用于描述图中节点之间的连接关系。 首先，我们需要理解什么是图。在计算机科学中，图是由顶点...
数据结构学习--图的邻接矩阵和邻接表存储
06-25
图的存储方式主要有两种：邻接矩阵和邻接表。这两种存储方式各有优缺点，适用于不同的场景。 邻接矩阵是一种二维数组，其中的元素表示图中顶点之间的边。对于无向图，邻接矩阵是对称的，即如果顶点i和顶点j之间有一...
代码 有向图关联矩阵和邻接矩阵的相互转换算法代码
06-04
代码 有向图关联矩阵和邻接矩阵的相互转换算法代码代码 有向图关联矩阵和邻接矩阵的相互转换算法代码代码 有向图关联矩阵和邻接矩阵的相互转换算法代码代码 有向图关联矩阵和邻接矩阵的相互转换算法代码代码 有向图...
c代码-邻接矩阵建立图
07-16
综上所述，`c代码-邻接矩阵建立图`涉及的知识点包括邻接矩阵的概念、C语言基础、图的输入输出处理、邻接矩阵的创建与更新，以及在实际问题中的应用。通过阅读和理解`main.c`代码，可以进一步学习这些概念并掌握构建...
数据结构------队列（Java语言描述）
最新发布
2402_82356599的博客
11-14 181
队列是一种数据结构，它遵循先进先出的原则。就像排队买东西一样，先到的人先得到服务，先进入队列的数据元素先被取出。例如，在一个银行排队系统中，顾客按照到达的先后顺序排队等待办理业务。第一个进入队列（排队）的顾客会第一个被服务并离开队列。
【数据结构】实验二 单链表的基本操作
drt_0506的博客
11-14 226
1）根据输入的一系列整数，以0标志结束，用头插法建立单链表，并输出单链表中各元素值，观察输入的内容与输出的内容是否一致。4）在单链表中查找第i个元素，如果查找成功，则显示该元素的值，否则显示该元素不存在。2）在单链表的第i个元素之前插入一个值为x的元素，并输出插入后的单链表中各元素值。3）删除单链表中第i个元素，并输出删除后的单链表中各元素值。掌握链表基本操作的算法实现，以及对相应算法的性能分析。掌握线性表的链式存储结构的表示和实现方法。
SystemVerilog学习笔记（八）：循环
qq_38156104的博客
11-11 932
循环只不过是将需要多次运行的语句包含在循环中，而不是重复编写这些语句。循环将根据条件语句运行多次，如果条件始终为真，则它会变成无限循环，系统将挂起。
C语言实现有向图邻接矩阵：存储与操作教程
在本篇关于有向图的邻接矩阵的C语言实现文章中，主要探讨了如何通过邻接矩阵的方式来表示和操作有向图。实验的主要目的是为了理解并掌握图数据结构中的邻接矩阵存储方式，它是一种二维数组结构，用于表示图中各个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值