数据结构---图（数组表示法）

最新推荐文章于 2022-07-05 21:03:00 发布
最新推荐文章于 2022-07-05 21:03:00 发布
阅读量3.6k 收藏 13
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dream_WHui/article/details/44020813
版权 
// MGraph_array.cpp : Defines the entry point for the console application.
/*-----CODE FOR FUN---------------
-------CREATED BY Dream_Whui------
-------2015-2-9--------------------*/

#include "stdafx.h"
#include <iostream>
#include <queue>
using namespace std;

#define        INFINITY        INT_MAX
#define        NAX_VERTEX_NUM    20
#define        VRtype            int
//#define        InfoType        char*
#define        VertexType        char*

#define   TRUE             1
#define   FALSE            0
#define   OK               1
#define   ERROR            0
#define   OVERFLOW          -2
#define   INFEASIBLE      -1

bool visited[NAX_VERTEX_NUM];
void(*VisitFunc)(VertexType);

typedef enum
{
    DG,DN,UDG,UDN//有向图，有向网，无向图，无向网
}GraphKind;

typedef struct ArcCell
{
    VRtype        adj;//无权图，用0或1；带权图，即权值
    //InfoType    *info;    
}ArcCell, AdjMatrix[NAX_VERTEX_NUM][NAX_VERTEX_NUM];

typedef struct //定义图的结构
{
    VertexType    vexs[NAX_VERTEX_NUM];//顶点向量
    AdjMatrix    arcs;                 //邻接矩阵
    int            vexnum,arcnum;         //定点数，边（弧）数
    GraphKind    kind;                 //图的种类标记
}MGraph;

int CreateDG(MGraph &G);//构造有向图
int CreateDN(MGraph &G);//构造有向网
int CreateUDG(MGraph &G);//构造无向图
int CreateUDN(MGraph &G);//构造无向网

int CreateGraph(MGraph &G)//采用数组（邻接矩阵）表示法，构造图G
{
    int n;
    cout<<"创建有向图（0），有向网（1），无向图（2），无向网（3）"<<endl;
    cin>>n;
    switch(n)
    {
    case DG:
        G.kind = DG;
        return CreateDG(G);//有向图
    case DN:
        G.kind = DN;
        return CreateDN(G);//有向网
    case UDG:
        G.kind = UDG;
        return CreateUDG(G);//无向图
    case UDN:
        G.kind = UDN;
        return CreateUDN(G);//无向网
    default:
        return ERROR;
    }
}

int LocateVex(MGraph G, VertexType V)//顶点V在图中的位置
{
    int i;
    for(i=0; i<G.vexnum; i++)
    {
        if(strcmp(G.vexs[i],V) == 0)
            return i;
    }
    return -1;//不存在，返回-1
}

int CreateUDG(MGraph &G)//构造无向图
{
    cout<<"输入顶点数，边数："<<endl;
    cin>>G.vexnum>>G.arcnum;
    int i,j,k;
    for(i=0; i<G.vexnum; i++)//构造顶点向量
    {
        cout<<"输入第"<<i+1<<"个顶点的名称：";
        G.vexs[i] = (VertexType)malloc( sizeof(char) );
        cin>>G.vexs[i];
    }
    for(i=0; i<G.vexnum; i++)//初始化领接矩阵
    {
        for(j=0; j<G.vexnum; j++)
        {
            G.arcs[i][j].adj = 0;
            //G.arcs[i][j].info = NULL;
        }
    }
    char *v1, *v2;
    v1 = (char*)malloc(sizeof(char));
    v2 = (char*)malloc(sizeof(char));
    for(k=0; k<G.arcnum; k++)//构造邻接矩阵
    {
        cout<<"输入相连的边（v1,v2）：";
        cin>>v1>>v2;
        i = LocateVex(G,v1);//定位顶点v1及v2在图中的位置
        j = LocateVex(G,v2);
        G.arcs[i][j].adj = 1;//权值
        G.arcs[j][i] = G.arcs[i][j];//无向图中，邻接矩阵对称
    }
    G.kind = UDG;//无向图
    return OK;
}

int CreateDG(MGraph &G)//构造有向图
{
    cout<<"输入顶点数，边数："<<endl;
    cin>>G.vexnum>>G.arcnum;
    int i,j,k;
    for(i=0; i<G.vexnum; i++)//构造顶点向量
    {
        cout<<"输入第"<<i+1<<"个顶点的名称：";
        G.vexs[i] = (VertexType)malloc( sizeof(char) );
        cin>>G.vexs[i];
    }
    for(i=0; i<G.vexnum; i++)//初始化领接矩阵
    {
        for(j=0; j<G.vexnum; j++)
        {
            G.arcs[i][j].adj = 0;
            //G.arcs[i][j].info = NULL;
        }
    }
    char *v1, *v2;
    v1 = (char*)malloc(sizeof(char));
    v2 = (char*)malloc(sizeof(char));
    for(k=0; k<G.arcnum; k++)//构造邻接矩阵
    {
        cout<<"输入连接的边（v1,v2）：";
        cin>>v1>>v2;
        i = LocateVex(G,v1);//定位顶点v1及v2在图中的位置
        j = LocateVex(G,v2);
        G.arcs[i][j].adj = 1;//权值
    }
    G.kind = DG;//有向图
    return OK;
}

int CreateUDN(MGraph &G)//采用数组（邻接矩阵）表示法，构造无向网
{
    //int IncInfo;
    cout<<"输入顶点数，边数："<<endl;
    cin>>G.vexnum>>G.arcnum;
    int i,j,k;
    for(i=0; i<G.vexnum; i++)//构造顶点向量
    {
        cout<<"输入第"<<i+1<<"个顶点的名称：";
        G.vexs[i] = (VertexType)malloc( sizeof(char) );
        cin>>G.vexs[i];
    }
    for(i=0; i<G.vexnum; i++)//初始化领接矩阵
    {
        for(j=0; j<G.vexnum; j++)
        {
            G.arcs[i][j].adj = INFINITY;
            //G.arcs[i][j].info = NULL;
        }
    }
    char *v1, *v2;
    v1 = (char*)malloc(sizeof(char));
    v2 = (char*)malloc(sizeof(char));
    int w;
    for(k=0; k<G.arcnum; k++)//构造邻接矩阵
    {
        cout<<"输入边及其权重（v1,v2,w）：";
        cin>>v1>>v2>>w;
        i = LocateVex(G,v1);//定位顶点v1及v2在图中的位置
        j = LocateVex(G,v2);
        G.arcs[i][j].adj = w;//权值
        G.arcs[j][i] = G.arcs[i][j];//无向网中，邻接矩阵对称
    }
    G.kind = UDN;//无向网
    return OK;
}

int CreateDN(MGraph &G)//采用数组（邻接矩阵）表示法，构造有向网
{
    //int IncInfo;
    cout<<"输入顶点数，边数："<<endl;
    cin>>G.vexnum>>G.arcnum;
    int i,j,k;
    for(i=0; i<G.vexnum; i++)//构造顶点向量
    {
        cout<<"输入第"<<i+1<<"个顶点的名称：";
        G.vexs[i] = (VertexType)malloc( sizeof(char) );
        cin>>G.vexs[i];
    }
    for(i=0; i<G.vexnum; i++)//初始化领接矩阵
    {
        for(j=0; j<G.vexnum; j++)
        {
            G.arcs[i][j].adj = INFINITY;
            //G.arcs[i][j].info = NULL;
        }
    }
    char *v1, *v2;
    v1 = (char*)malloc(sizeof(char));
    v2 = (char*)malloc(sizeof(char));
    int w;
    for(k=0; k<G.arcnum; k++)//构造邻接矩阵
    {
        cout<<"输入边及其权重（v1,v2,w）：";
        cin>>v1>>v2>>w;
        i = LocateVex(G,v1);//定位顶点v1及v2在图中的位置
        j = LocateVex(G,v2);
        G.arcs[i][j].adj = w;//权值
    }
    G.kind = DN;//有向网
    return OK;
}

VertexType GetVex(MGraph G, int v)//返回图中第V个顶点
{
    if(v<1 || v>G.vexnum)
        return NULL;
    else
        return G.vexs[v-1];//顶点数组以标号0开始
}

int PutVex(MGraph &G, VertexType v, VertexType value)//修改图中顶点v的名称为value
{
    int i = LocateVex(G,v);
    if(i<0)
        return ERROR;
    else
        strcpy(G.vexs[i],value);
    return OK;
}

VertexType FirstAdjVex(MGraph G, VertexType v)//返回顶点V的第一个邻接点
{
    int i,j,k;
    k = LocateVex(G,v);//定位顶点v在图中的位置
    if(k<0)
        return NULL;
    if(G.kind % 2 == 1)//网
        j = INFINITY;
    else
        j = 0;//图
    for(i=0; i<G.vexnum; i++)
    {
        if(G.arcs[k][i].adj != j)//邻接矩阵中该行第一个不为j的分量所在的列号
            return GetVex(G,i+1);
    }
    return NULL;
}

VertexType NextAdjVex(MGraph G, VertexType v, VertexType w)//返回顶点V的(相对于w)下一个邻接点
{
    int i,j,k,p;
    i = LocateVex(G,v);
    j = LocateVex(G,w);
    if(i<0 || j<0)
        return NULL;
    if(G.kind % 2 == 1)//网
        k = INFINITY;
    else
        k = 0;//图
    for(p=j+1; p<G.vexnum; p++)
    {
        if(G.arcs[i][p].adj != k)
            return GetVex(G,p+1);
    }
    return NULL;
}

void InsertVex(MGraph &G, VertexType v)//插入顶点
{
    int j,i;
    if(G.kind % 2 == 1)
        j = INFINITY;//网
    else
        j = 0;//图
    G.vexs[G.vexnum] = (VertexType)malloc(sizeof(VertexType));
    strcpy(G.vexs[G.vexnum],v);
    for(i=0; i<=G.vexnum; i++)
        G.arcs[G.vexnum][i].adj = G.arcs[i][G.vexnum].adj = j;//初始化权值
    G.vexnum++;
}

int DeleteVex(MGraph &G, VertexType v)//删除顶点
{
    int i,j,k,p;
    k = LocateVex(G,v);
    if(k<0)
        return ERROR;
    if(G.kind % 2 == 1)
        j = INFINITY;//网
    else
        j = 0;//图

    for(i=0; i<G.vexnum; i++)//入弧（出度）
        if(G.arcs[k][i].adj != j)
            G.arcnum--;
    
    if(G.kind < 2)//有向
        for(i=0; i<G.vexnum; i++)
            if(G.arcs[i][k].adj != j)
                G.arcnum--;

    for(i=k+1; i<G.vexnum; i++)//顶点向量第k个之后的都往前移
        strcpy(G.vexs[i-1],G.vexs[i]);
    //free(G.vexs[i-1]);
    G.vexs[i-1] = NULL;

    for(i=0; i<G.vexnum; i++)//邻接矩阵中每行从第k列之后的都往前移
    {
        for(p=k+1; p<G.vexnum; p++)
            G.arcs[i][p-1] = G.arcs[i][p];
        G.arcs[i][p-1].adj = j;
    }
    G.arcs[i-1][p-1].adj = j;

    for(i=k+1; i<G.vexnum; i++)//邻接矩阵中每列从第k行之后的都往上移
    {
        for(p=0; p<G.vexnum-1; p++)
        {    G.arcs[i-1][p] = G.arcs[i][p];
            if(i == G.vexnum-1)
                G.arcs[i][p].adj = j;
        }
    }
    G.vexnum--;
    return OK;
}

int InsertArc(MGraph &G, VertexType v, VertexType w)//插入一条边或弧
{
    int i,j,weight;
    i = LocateVex(G,v);//尾
    j = LocateVex(G,w);//头
    if(i<0 || j<0)
        return ERROR;
    G.arcnum++;
    if(G.kind % 2 == 1)
    {  
        cout<<"输入权值：";
        cin>>weight;
    }
    else
        weight = 1;
    if(G.kind < 2)//有向
        G.arcs[i][j].adj = weight;
    else//无向
        G.arcs[j][i].adj= G.arcs[i][j].adj=weight;
    return OK;
}

int DeleteArc(MGraph &G, VertexType v, VertexType w)//删除一条边
{
    int i,j,weight;
    i = LocateVex(G,v);//尾
    j = LocateVex(G,w);//头
    if(i<0 || j<0)
        return ERROR;
    G.arcnum--;
    if(G.kind % 2 == 1)//网
        weight = INFINITY;
    else//图
        weight = 1;
    if(G.kind < 2)//有向
        G.arcs[i][j].adj = weight;
    else
        G.arcs[i][j].adj = G.arcs[j][i].adj = weight;
    return OK;
}

void Display(MGraph G)//输出邻接矩阵
{
    int i,j;
    for(i=0; i<G.vexnum; i++)
    {
        for(j=0; j<G.vexnum; j++)
        {
            cout<<"("<<G.vexs[i]<<"->"<<G.vexs[j]<<",";
            if(G.arcs[i][j].adj == INFINITY)
                cout<<"oo";
            else
                cout<<G.arcs[i][j].adj;
            cout<<")"<<" ";
        }
        cout<<endl;
    }
}

void Visit(VertexType e)
{
    cout<<e;
}

void DFS(MGraph G, int v)
{
    visited[v] = TRUE;//访问第v个结点
    VisitFunc(G.vexs[v]);
    VertexType w;
    for(w=FirstAdjVex(G,G.vexs[v]); w!=NULL; w=NextAdjVex(G,G.vexs[v],w) )//对第v个顶点尚未访问的邻接结点w递归调用DFS
    {
        if(!visited[LocateVex(G,w)])
            DFS(G,LocateVex(G,w));
    }

}

void DFSTraverse(MGraph G, void(*Visit)(VertexType))//深度优先遍历
{
    int v;
    VisitFunc = Visit;
    for(v=0; v<G.vexnum; v++)
        visited[v] = FALSE;//访问标志数组
    for(v=0; v<G.vexnum; v++)
        if(!visited[v])//对尚未访问的顶点调用DFS
            DFS(G,v);
    cout<<endl;
}

void BFSTraverse(MGraph G, void(*Visit)(VertexType))//广度优先搜索算法
{
    int i,u;
    VertexType w;
    for(i=0; i<G.vexnum; i++)//访问标记数组初始化
        visited[i] = FALSE;
    queue<int> Q;            //置空的辅助队列
    for(i=0; i<G.vexnum; i++)
    {
        if(!visited[i])
        {
            visited[i] = TRUE;
            Visit(G.vexs[i]);
            Q.push(i);
            while(!Q.empty())
            {
                u = Q.front();//对头元素出队并置为u
                Q.pop();
                for(w=FirstAdjVex(G,G.vexs[u]); w!=NULL; w=NextAdjVex(G,G.vexs[u],w))
                {                                    //w为u的尚未访问的邻接顶点
                    if(!visited[LocateVex(G,w)])
                    {
                        visited[LocateVex(G,w)] = TRUE;
                        Visit(w);
                        Q.push(LocateVex(G,w));
                    }
                }
            }
        }
    }
    cout<<endl;
}

int main(int argc, char* argv[])
{
    MGraph G;
    CreateGraph(G);
    int i,j;
    Display(G);
    for(i=0; i<G.vexnum; i++)
        cout<<"第"<<i+1<<"个顶点的名字："<<GetVex(G,i+1)<<endl;
    cout<<endl;

    VertexType w;
    for(i=1; i<=G.vexnum; i++)
    {
        for(w=FirstAdjVex(G,G.vexs[i-1]); w!=NULL; w=NextAdjVex(G,G.vexs[i-1],w))
            cout<<w<<" ";
        cout<<endl;
    }
    DFSTraverse(G,Visit);
    BFSTraverse(G,Visit);
    //PutVex(G,"v1","v0");
    //for(i=0; i<G.vexnum; i++)
    //cout<<"第"<<i+1<<"顶点的名字："<<GetVex(G,i+1)<<endl;
    //cout<<endl;

    //cout<<FirstAdjVex(G,G.vexs[0])<<endl;
    //cout<<NextAdjVex(G,G.vexs[0],G.vexs[1])<<endl;

    //DeleteVex(G,G.vexs[0]);
    //Display(G);

    //InsertVex(G,"A1");
    //Display(G);
    return 0;
}

Dream_WHui
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构学习笔记 --- 图（数组表示法）
whz_zb的专栏
03-06 6438
1. 图的数组表示法 2. 代码 #include "ds.h" // 图的数组(邻接矩阵)存储表示 #define INFINITY INT_MAX // 用整型最大值代替∞ #define MAX_VERTEX_NUM 26 // 最大顶点个数 #define MAX_NAME 5 // 顶点字符串的最大长度+1 #define MAX_INFO 20
图的数组表示法-数据结构(18)
健景的博客
05-21 922
一、图 参见P160-P163，关于图这种数据结构，其实就是点与弧，因此表示出这种弧也就表示图。 二、存储结构 //================图的存储结构-数组表示法 #define INFINITY 9999 //最大值 #define MAX_VERTEX_NUM 20 //最大顶点个数 typedef int VRType; typedef char VertexType;//用
数据结构——图的数组（邻接矩阵）表示法
赵满刚的博客
11-20 7810
数组表示无向图 用两个数组（vexs[],arcs[][]）分别存储数据元素（顶点）的信息和数据元素之间的关系（边或弧）的信息。以二维数组表示有n个顶点的图时，需存放n个顶点信息和n^2个弧信息存储量。若考虑无向图的邻接矩阵的对称性，则可采用压缩存储的方式只存入矩阵的下三角（或上三角）元素。下示算法时在邻接矩阵存储结构MGraph上对图构造的实现框架，它根据G的种类调用具体构造的算法。例如G为无...
数据结构图的数组表示法以及深度,广度遍历
我是一只小小鸟，想要飞却怎么也飞不高
12-15 1738
#include"stdio.h" #include"stdlib.h" #define MAX_VERTEX_NUM 10 #define OK 1 #define ERROR 0 #define OVERFLOW -1 #define maxsize 100 typedef int QElemType; typedef int VRType; typedef int InfoType; typ
C数据结构学习历程(5) 图之数组表示法
snailYWW的博客
08-09 1162
我是参照《严蔚敏数据结构ppt》http://wenku.baidu.com/view/3ff16fc20242a8956aece41d.html以及《严蔚敏c数据结构视频》来写的，因为ppt上有些错，而视频上的代码不全，自己另写了。ppt上错哪，我就不指出了，大家可以对照着看，就能发现不同之处。其中图这部分主要是《大话数据结构》来的。对于图前面的知识，之前写了但是忘了上传。     对于图的数
链表_数据结构--链表_
10-01
栈是一种后进先出（LIFO）的数据结构，通常用数组实现，但在某些情况下，如内存限制或动态增长需求时，链表可以作为有效的替代方案。 链表模拟栈的优势在于，由于链表的插入和删除操作通常比数组更快，尤其是在数据...
易语言源码挂号法-自定义数据数组排序.rar
03-30
这样的数组可以更灵活地处理复杂的数据结构。在描述中提到的“挂号法”，可能是指一种特殊的排序算法，用于对这种自定义数据数组进行排序。 排序是编程中的常见操作，尤其在处理大量数据时。在易语言中，有多种排序...
数据结构实战 -- 线性结构动态数组表示法（C实现源码）
10-24
在"数据结构实战 -- 线性结构动态数组表示法（C实现源码）"项目中，包含以下关键知识点： 1. **动态内存分配**：在C语言中，`malloc()`函数用于动态分配内存，而`realloc()`可以扩展或收缩已分配的内存。这些函数...
数据结构实战 -- 线性结构静态数组表示法（C实现源码）
10-21
本文将深入探讨静态数组表示法在实现线性结构中的应用，并通过C语言源码来解析其工作原理。 静态数组是一种预先分配固定大小的内存空间来存储数据的结构。在C语言中，数组定义时需要指定长度，且长度一旦确定，无法...
数据结构基础6.1：图的表示方法
u010815257的博客
11-23 715
图的表示方法有多种：1. 邻接矩阵法 2. 邻接链表法 3. 十字链表法 4. 邻接多重表法 本文主要介绍邻接矩阵法和邻接链表法。 1.邻接矩阵法 ： 好处：直观简单；方便检查任一对顶点间是否存在边；方便找任一顶点的所有邻接点；方便计算任一顶点的度。 坏处：浪费空间，对于稀疏图会有大量无效元素。 2.邻接矩阵法： 好处：方便找任一顶点的所有邻接点；节约稀疏图的空间 坏处：对于检查任
浙大数据结构：图的定义及表示方法
Tandy12356_的博客
09-04 272
还是按照习惯，先附上PPT讲解，文章后面是代码部分。 一、图的定义以及数据集 二、图的邻接矩阵表示法 三、图的邻接表表示法 邻接表的表示方法不唯一，而且所占空间较多，所以一定要够稀疏才合算。 四、图的邻接矩阵表示法代码 #include<iostream> using namespace std; #include<stdlib.h> #define MAXN 100 int G[MAXN][MAXN], Nv,...
12.图——数组表示法
StaticMan
03-13 6056
无向图：V是顶点的集合，VR是弧的集合，弧用(顶点，顶点)表示。有n个顶点，n(n-1)/2条弧的图，是无向完全图。 权：图的弧的相关系数。 网：带权的图。 子图：顶点和弧都包含于原图的图 邻接：两顶点之间有弧，则无向图a、b互为邻接点，有向图a邻接到b。 依附：弧依附于其两个顶点。 顶点的度：与顶点相关联的弧的个数。有向图有入度、出度之分。 路径：从a到b途径顶点组成的序列。有向图
数据结构及算法之图
clky00的博客
05-23 612
图   图的一些概念定义在这里不做介绍了。 1 抽象数据类型图的形式定义 ADT Graph{   数据对象V: V是具有相同特性的数据元素的集合，称为顶点集。   数据关系R:R = {VR}          VR={<v,w> | v,w ε V且p(v,w)，<v,w>表示从v到w的弧，谓词p(v,w)定义了弧<v,w>的意义或信息}   基本操作P:   CreateGraph( &G, V, VR )     初始条件:V是图的顶点集，VR是图中弧的
第四章--邻接表数组表示无向图
a219219219219的博客
07-29 416
无向图中的顶点用数组的索引表示，该索引中的元素用bag表示，而这些元素指的是索引对应的顶点所连接的顶点。 public class Graph { private final int V;// 顶点个数 private int E;// 边的数目 private Bag<Integer> adj[];// 邻接表 //初始化邻接表 public Graph(int v) { this.V = v; this.E = 0;
C语言无向网的数组表示法储存以及Kruskal算法的实现
weixin_45883188的博客
07-31 402
PS：本代码实现受此文启发 Kruskal算法代码实现需要两步： ①弧结点按照权重从小到大排序(注意交换的时候是交换结构体) ②判断这个弧能不能成环，如果不能成环，就加入到其中 对于第二点的实现分为了两步，首先有一个Parent整型数组，长度为弧的数目，初始化为0，在程序运行过程中，如果Parent[i]为0，说明这是根或者是一个只有根节点的树，如果不为0，说明有父亲，但不一定是根，所以需要寻找父亲的父亲，直到找到Parent[n] = 0，那么n才是最终的根节点，这就是Find_Root函数的作用。 那么
无向带权图的邻接矩阵表示法
热门推荐
06-01 2万+
/*无向带权图的邻接矩阵表示法*/ #include<stdio.h> #define vnum 20 typedef struct gp { int vexs[vnum]; /*顶点信息*/ int arcs[vnum][vnum]; /*邻接矩阵*/ int vexnum,arcnum; /*顶
C语言无向网的数组表示法储存以及Prim算法的实现
weixin_45883188的博客
07-31 471
实现内容: ①无向网的数组表示法储存实现 ②普利姆算法 数组表示法：分两部分，一个顶点数组，一个邻接矩阵 两结点间没有连接 用MAX_INT表实 /* 实现内容: ①无向网的数组表示法储存实现 ②普利姆算法 数组表示法：分两部分，一个顶点数组，一个邻接矩阵 两结点间没有连接 用MAX_INT表实 VS2019编译通过 2020.7.31 */ #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <std
用邻接矩阵创建无向网
little_spice的博客
02-12 1841
#include&lt;bits/stdc++.h&gt; #define maxInt 32767 #define vexmax 100 using namespace std; typedef struct{ char vex[vexmax]; int arc[vexmax][vexmax]; int vexnum,arcnum; }Graph; int Locate(Graph g...
图的邻接矩阵存储及遍历操作
qq_45917176的博客
07-05 1万+
数据结构--图的邻接矩阵存储及遍历操作

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值