数据结构图的实现（邻接矩阵法和邻接表法）

已于 2023-11-16 15:02:46 修改
阅读量684 收藏 17
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构
于 2023-11-16 14:56:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z1zyy/article/details/134440815
版权

目录

一、邻接矩阵法

1.结构体

2.操作函数

1）邻接矩阵法创建图

2)获取内容为e的结点下标

3）插入顶点

4）删除顶点v

5）找到v的第一个邻接点

6）找到v除了w后第一个邻接点

7）图的遍历

a.深度优先遍历

b.广度优先搜索，使用队列

8）基于BFS的单源最短路径

9）prim算法

10)kruskal算法

11)dijkstra求单源最短路径

12）floyd算法最短路径

13）拓扑排序

二、邻接表法

1.结构体

2.操作函数

1）返回顶点u的下标

2）创建邻接表

3）求顶点x的第一个邻接点

4)顶点v除去w后第一个邻接点

5）拓扑排序

6）图的遍历

a.广度优先遍历

b.深度优先遍历

三、其他存储结构

1.十字链表法  ------只针对有向图

2.邻接多重表 ---只针对无向图

一、邻接矩阵法

1.结构体

typedef struct{
    VertexType Vex[MaxVertexNum]; //顶点表
    int Edge[MaxVertexNum][MaxVertexNum]; //邻接矩阵，边表  如果带权图，就使用int类型
    int vexnum,arcnum;//当前的顶点数和边数
}MGraph;

2.操作函数

1）邻接矩阵法创建图

void CreatMGraph(MGraph &G,int i)  //i:0 无向图不带权值  1 无向带权  2 有向不带权  3 有向带权
{
    int v,e;
    cout<<"请输入顶点数和边数"<<endl;
    cin>>v>>e;
    G.vexnum=v;
    G.arcnum=e;
    cout<<"请输入顶点信息"<<endl;
    for (int i=0;i<G.vexnum;i++) {
        cin>>G.Vex[i];
    }
    for (int i=0;i<G.vexnum;i++) {
        for(int j=0;j<G.vexnum;j++){
            G.Edge[i][j]=INF;
        }
    }
    if(i==0){
        cout<<"请输入边的两端顶点值"<<endl;
        for (int i=0;i<G.arcnum;i++) {
                VertexType v1,v2;
                cin>>v1>>v2;
                int a1=GetIndexByElem(G,v1);
                int a2=GetIndexByElem(G,v2);
                G.Edge[a1][a2]=1;
                G.Edge[a2][a1]=1;
    }
    if(i==1){
        cout<<"请输入边的两端顶点值和权值"<<endl;
        for (int i=0;i<G.arcnum;i++) {
                VertexType v1,v2;
                int cost;
                cin>>v1>>v2>>cost;
                int a1=GetIndexByElem(G,v1);
                int a2=GetIndexByElem(G,v2);
                G.Edge[a1][a2]=cost;
                G.Edge[a2][a1]=cost;
        }
    }
    
        }
     if(i==2){
            cout<<"请输入弧尾到弧头"<<endl;
            for (int i=0;i<G.arcnum;i++) {
                    VertexType v1,v2;
                    cin>>v1>>v2;
                    int a1=GetIndexByElem(G,v1);
                    int a2=GetIndexByElem(G,v2);
                    G.Edge[a1][a2]=1;
        }
            }
         if(i==3){
                cout<<"请输入弧尾到弧头以及权值"<<endl;
                for (int i=0;i<G.arcnum;i++) {
                        VertexType v1,v2;
                        int w;
                        cin>>v1>>v2>>w;
                        int a1=GetIndexByElem(G,v1);
                        int a2=GetIndexByElem(G,v2);
                        G.Edge[a1][a2]=w;
            }


            }

}

2)获取内容为e的结点下标

int GetIndexByElem(MGraph G,VertexType e)
{
    //只用去顶点表遍历即可
    for (int i=0;i<G.vexnum;i++) {
        if(e==G.Vex[i]){
            return i;
        }
    }
    return -1;
}

3）插入顶点

bool InsertVex(MGraph &G)
{
    cout<<"请输入你要插入的顶点信息以及与其相关的边条数"<<endl;
    VertexType v;
    int e;
    cin>>v>>e;
    G.vexnum++;
    G.arcnum+=e;
    //vexnum-1为下标
    G.Vex[G.vexnum-1]=v;
    for (int i=0;i<G.vexnum;i++) {
        //行初始为0
        G.Edge[G.vexnum-1][i]=0;
        //列初始为0
        G.Edge[i][G.vexnum-1]=0;
    }
    cout<<"请输入该顶点相邻的顶点值"<<endl;
    for (int i=0;i<e;i++) {
        VertexType v1,v2;
        cin>>v1>>v2;
        int index1 = GetIndexByElem(G,v1);
        int index2 = GetIndexByElem(G,v2);
        G.Edge[index1][index2]=1;
        G.Edge[index2][index1]=1;
    }
    return true;

}

4）删除顶点v

bool DeleteVex(MGraph &G,VertexType v)
{
    //更新边表
    for (int i=GetIndexByElem(G,v);i<G.vexnum-1;i++) {
        for (int j=0;j<G.vexnum;j++) {
            G.Edge[i][j]=G.Edge[i+1][j];
            G.Edge[j][i]=G.Edge[i][j];
        }
    }
    //更新顶点表
    for (int i=GetIndexByElem(G,v);i<G.vexnum-1;i++) {
            G.Vex[i]=G.Vex[i+1];

    }
     G.vexnum--;
     return 1;
}

5）找到v的第一个邻接点

int FirstNeighbor(MGraph G, int v)
{
        int k;
        for(k=1;k<=G.vexnum;k++)
        {
            if(G.Edge[v][k]==1)
                break;
        }
        if(k<=G.vexnum)
            return k;
        else
            return -1;
}

6）找到v除了w后第一个邻接点

int NextNeighbor(MGraph G, int v, int w)
{
        int j;
        for(j=w+1;j<=G.vexnum;j++)
        {
            if(G.Edge[v][j]==1)
                break;
        }
        if(j<=G.vexnum)
            return j;
        else
            return -1;
}

7）图的遍历

a.深度优先遍历
void DFS(MGraph G, int i)
{
     visit(G,i);
     visited[i]=1;
     for (int w=FirstNeighbor(G,i);w>=0;w=NextNeighbor(G,i,w)) {
         if(!visited[w])
             DFS(G,w);
     }
}

void DFSTraverse(MGraph G)
{
  for (int i = 0; i < G.vexnum; i++)
         visited[i] = 0;     //初始化所有顶点都为未访问

        for (int i = 0; i < G.vexnum; i++)
            if (!visited[i])
                DFS(G, i);
}
b.广度优先搜索，使用队列
void BFS(MGraph G, int v)
{
    visit(G,v);
    visited[v]=1;

    EnLinkQueue(Q,v);

    while (!LinkQueueEmpty(Q)) {
       DeLinkQueue(Q,v);
        for (int w = FirstNeighbor(G,v);w>=0;w=NextNeighbor(G,v,w)) {
            if(!visited[w]){
                visit(G,w);
                visited[w]=1;
                EnLinkQueue(Q,w);
            }
        }
    }
}

void BFSTraverse(MGraph G)
{
    for(int i=0;i<G.vexnum;i++){
        visited[i]=0;
    }
    InitLinkQueue(Q);

    for(int i=0;i<G.vexnum;i++){
        if(!visited[i])
            BFS(G,i);
    }
}

8）基于BFS的单源最短路径

int D[];
int path[];
void BFS_MIN_Distance(MGraph G, int u)
{
    for(int i=0;i<G.vexnum;i++){
        D[i]=INF;
      path[i]=-1;
    }

    visited[u]=true;
    D[u]=0;

    EnLinkQueue(Q,u);

     while (!LinkQueueEmpty(Q)) {
     DeLinkQueue(Q,u);
     for (int w = FirstNeighbor(G,u);w>=0;w=NextNeighbor(G,u,w)) {
           if(!visited[w]){
                visit(G,w);
               visited[w]=1;
               D[w]=D[u]+1;
               path[w]=u;
               EnLinkQueue(Q,w);
              }
          }
      }

}

9）prim算法

void Prim(MGraph G, int v, int &sum)
{
    int *lowcost=(int *)malloc(sizeof(int)*G.vexnum);
    int *vset=(int *)malloc(sizeof(int)*G.vexnum);
    int i,j,k,min;


    for (i=0;i<G.vexnum;i++) {
        lowcost[i]=G.Edge[v][i];
        vset[i]=0;
    }
    vset[v]=1;
    sum=0;

    for (i=0;i<G.vexnum-1;i++) {
        min=999999;
        for (j=0;j<G.vexnum;j++) {
            if(vset[j]==0&&lowcost[j]<min){
                min=lowcost[j];
                k=j;
            }
        }

        vset[k]=1;
        sum+=min;

        for (j=0;j<G.vexnum;j++) {
            if(vset[j]==0&&G.Edge[k][j]<lowcost[j]){
                lowcost[j]=G.Edge[k][j];
            }
        }
    }

}

10)kruskal算法

void getroad(MGraph g)
{
    int index = 0;
    for (int i=0;i<g.vexnum;i++) {
        for (int j=0;j<i;j++) {
            if(g.Edge[i][j]!=INF){
                roads[index].a=i;
                roads[index].b=j;
                roads[index].w=g.Edge[i][j];
                index++;
            }
        }
    }
}

void kruskal(MGraph G, int &sum, Road1 *road)
{
    for (int i=0;i<G.vexnum;i++) {
        v[i]=i;
    }

    sum=0;
    quicksort(road,0,G.arcnum-1);

    for (int i=0;i<G.arcnum;i++) {
        int av=getroot(road[i].a);
        int bv=getroot(road[i].b);
        if(av!=bv){
            v[av]=bv;
            sum+=road[i].w;
        }

    }
}

11)dijkstra求单源最短路径

void dijkstra(MGraph G, int v, int *dist, int* path1)
{
     int *set=(int*)malloc(sizeof(int)*G.vexnum);
     for (int i=0;i<G.vexnum;i++) {
         dist[i]=G.Edge[v][i];
         set[i]=0;

         if(G.Edge[v][i]!=INF){
             path1[i]=v;
         }
         else {
             path1[i]=-1;
         }
     }
     set[v]=1;
     path1[v]=-1;
     int u;
     for (int i=0;i<G.vexnum-1;i++) {
         int min=INF;
          u=-1;
         for (int j=0;j<G.vexnum;j++) {
             if(set[j]==0&&min>dist[j])
                 min=dist[j],u=j;

         }
     }
     set[u]=1;
     for (int j=0;j<G.vexnum;j++) {
         if(set[j]==0&&dist[j]>dist[u]+G.Edge[u][j]){
             dist[j]=dist[u]+G.Edge[u][j];
             path1[j]=u;
         }
     }
     free(set);
}

12）floyd算法最短路径

void floyd(MGraph G, int path[][20], int dist[][20])
{
    for (int i=0;i<G.vexnum;i++) {
        for (int j=0;j<G.vexnum;j++) {
            dist[i][j]=G.Edge[i][j];
            path[i][j]=-1;
        }
    }
    for (int k=1;k<G.vexnum;k++) {
        for (int i=0;i<G.vexnum;i++) {
            for (int j=0;j<G.vexnum;j++) {
                if(dist[i][j]>dist[i][k]+dist[k][j]){
                    dist[i][j]=dist[i][k]+dist[k][j];
                    path[i][j]=k;
                }
            }
        }
    }
}

13）拓扑排序

int *   GetIndegree(MGraph &G)
{
    int *indegree=(int*)malloc(sizeof (int)*G.vexnum);
    for (int i=0;i>G.vexnum;i++) {
        indegree[i]=0;
    }
    for (int i=0;i<G.vexnum;i++) {
        for (int j=0;j<G.vexnum;j++) {
            if(G.Edge[i][j]!=0)
                indegree[i]++;
        }
    }
    return indegree;
}
SqStack s;
bool topSort(MGraph &G)
{
    int count;
    int *indegree=GetIndegree(G);
    InitStack(s);
    for (int i=0;i<G.vexnum;i++) {
        if(indegree[i]==0)
            push(s,i);
    }
    while (StackEmpty(s)) {
        count++;
        int v;
        pop(s,v);
        cout<<v+1<<" ";
        for (int i=0;i<G.vexnum;i++) {
            if(G.Edge[v][i]==1)
                indegree[i]--;
            if(indegree[i]==0)
                push(s,i);
        }
    }
    free(indegree);
    return count==G.vexnum;
}

二、邻接表法

1.结构体

//边
typedef struct ArcNode{
    int adjvex; //邻接点在数组的下标
    ArcNode *next;//下一个邻接点
    int weight;
}ArcNode;

//顶点
typedef struct VNode{
    VertexType data; //顶点的数据
    ArcNode *first; //第一条边
    int count; //记录
}VNode,AdjList[MaxVertexNum];

//图
typedef  struct{
    AdjList vertices;
    int vexnum,arcnum;
    int kid;
}ALGraph;

2.操作函数

1）返回顶点u的下标

int LocateVex(ALGraph G, VertexType u)
{
        int i;
        for (i = 0; i < G.vexnum && G.vertices[i].data != u; i++);
        if (i == G.vexnum) return -1; //不存在该顶点
        else return i;
}

2）创建邻接表

bool CreatALGraph(ALGraph &G)
{
    cout<<"请输入结点数和边数"<<endl;
    cin>>G.vexnum>>G.arcnum;
    cout<<"请输入各结点值"<<endl;
    for (int i=0;i<G.vexnum;i++) {
        cin>>G.vertices[i].data;
        G.vertices[i].first=NULL;
        G.vertices[i].count=0;
    }
    cout<<"请输入一条边依附的两个顶点值"<<endl;
    for (int j=0;j<G.arcnum;j++) {
        VertexType v1,v2;
        cin>>v1>>v2;
        int a=LocateVex(G,v1);
        int b=LocateVex(G,v2);
        ArcNode *p1=(ArcNode *)malloc(sizeof (ArcNode));
        p1->adjvex=b;
        p1->next=G.vertices[a].first;
        G.vertices[b].count++;
        G.vertices[a].first=p1;

        ArcNode*p2=(ArcNode *)malloc(sizeof (ArcNode));
        p2->adjvex=a;
        p2->next=G.vertices[b].first;
        G.vertices[b].first=p2;
    }
    return true;

}

3）求顶点x的第一个邻接点

int FirstNeighbor(ALGraph G, VertexType x)
{
    if(x != -1){
            ArcNode *p = G.vertices[x].first; //对应边链表的第一个结点
            if(p!=NULL){
                return p->adjvex;
            }
        }
}

4)顶点v除去w后第一个邻接点

int NextNeighbor(ALGraph G, VertexType v, VertexType w)
{
    if(v!=-1 && w!=-1){
            ArcNode *p = G.vertices[v].first; //对应边链表的第一个结点
            while(p!=NULL && p->adjvex!=w) 
                p=p->next; //找到v的邻接点w
            if(p!=NULL && p->next!=NULL) //w存在且w的邻接点存在
                return p->next->adjvex;
        }
        return -1; 
}

5）拓扑排序

int topSort(ALGraph *G)
{
    int i,j,count=0;
    ArcNode *p;

    InitStack(s);
    for (int i=0;i<G->vexnum;i++) {
        if(G->vertices[i].count==0)
            push(s,i);
    }
    while (StackEmpty(s)) {
            pop(s,i);

        ++count;
        cout<<i+1<<",";
        p=G->vertices[i].first;
        while (p!=NULL) {
            j=p->adjvex;
            --G->vertices[j].count;
            if(G->vertices[j].count==0)
                push(s,j);
        }
        p=p->next;
    }
    return  count==G->vexnum?1:0;
}

6）图的遍历

a.广度优先遍历
void BFS(ALGraph G, int v)
{
    visit(G,v);
    visited[v]=1;

    EnLinkQueue(Q,v);


    while (!LinkQueueEmpty(Q)) {
       DeLinkQueue(Q,v);
        for (int w = FirstNeighbor(G,v);w>=0;w=NextNeighbor(G,v,w)) {
            if(!visited[w]){
                visit(G,w);
                visited[w]=1;
                EnLinkQueue(Q,w);
            }
        }
    }
}

void BFSTraverse(ALGraph G)
{
    for(int i=0;i<G.vexnum;i++){
        visited[i]=0;
    }
    InitLinkQueue(Q);

    for(int i=0;i<G.vexnum;i++){
        if(!visited[i])
            BFS(G,i);
    }
}
b.深度优先遍历
void DFS(ALGraph G, int v)
{
    visit(G,v);
    visited[v]=true;
    for (int w = FirstNeighbor(G,v);w>=0;w=NextNeighbor(G,v,w)) {
      if(!visited[w]){
      DFS(G,w);
      }

}
}

void DFSTraverce(ALGraph G)
{
    for (int v=0;v<G.vexnum;v++) {
        visited[v]=false;
    }
    for(int v=0;v<G.vexnum;v++){
        if(!visited[v])
            DFS(G,v);
    }

}

三、其他存储结构

1.十字链表法  ------只针对有向图

//十字链表法 --- 有向图
typedef  struct AcrNode{
    int tailvex,headvex;
    AcrNode *hlink,*tlink;//指向弧尾和弧头相同的结点。
    int info;
}ArcNode;

//顶点表结点
typedef  struct VNode{
    VertexType data;
    AcrNode *firstin,*firstout;//第一条入弧和出弧
}VNode;

typedef struct{
    VNode xlist[MaxVertexNum];
    int vexnum,arcnum;
}Graph;

2.邻接多重表 ---只针对无向图

//邻接多重表---无向图
typedef struct ArcNode{
    bool mark;
    int ivex,jvex;
    ArcNode *ilink,*jLink; //依附于顶点i，j的下一条边
}ArcNode;

typedef struct VNode{
    VertexType data;
    ArcNode *firstEdge;
}VNode;

typedef struct {
    VNode adjMuList[MaxVertexNum];
    int acrnum,vexnum;
}Graph;

yz1.
关注
专栏目录
数据结构之图的实现
weixin_43737924的博客
04-16 2166
图(graph)
图的邻接矩阵存储及操作
最新发布
lightfuturezyx99的博客
11-02 1043
图的邻接矩阵存储及遍历操作 ①图的邻接矩阵存储及求临接点操作 ②图的深度优先遍历 ③图的广度优先遍历
【数据结构】图的实现
qq_53893431的博客
12-01 1594
图的实现和遍历
数据结构之图（内含Java代码实现）
Java笔记
08-14 5672
数据结构之图 在前面我们所介绍的树的数据结构中，我们可以明显的感觉到，树的表示是分层的，例如父子关系，而其他关系只能间接的表示，例如同级关系。而图却不受这种限制。图是由顶点（或结点）及顶点之间的关系组成的集合。通常，图中的顶点数量或者一个顶点与其他顶点之间的连线的个数不受限制。（C++数据结构与算法） 定义(百度百科) 主要有以下两种定义。 二元组的定义： 图G是一个有序二元组(V,E...
数据结构——图的定义和实现
weixin_46096297的博客
01-22 721
图相对于前面稍难些 这里记下概念 以加深印象
邻接矩阵与邻接表
http://kingim.cn/
02-07 1112
// 邻接矩阵 #include #include #define MAXN 100 int Edge[MAXN][MAXN]; int main() { // freopen("input.txt","r",stdin); // freopen("output.txt","w",stdout); int m,n,i,j,id,od,u,v; while(scanf(
数据结构基础 之 图 的 邻接矩阵实现与邻接表实现
稚枭天卓
07-11 2817
首先，本文给出邻接表与邻接矩阵的概念，然后，对相关概念进行阐释并给出实现源码，最后，对两种方法进行了比较分析给出给进一步的改进方向。
数据结构学习--图的邻接矩阵和邻接表存储
06-25
图的存储方式主要有两种：邻接矩阵和邻接表。这两种存储方式各有优缺点，适用于不同的场景。 邻接矩阵是一种二维数组，其中的元素表示图中顶点之间的边。对于无向图，邻接矩阵是对称的，即如果顶点i和顶点j之间有一...
数据结构程序之图（邻接表和邻接矩阵法）
07-16
实现图的基本功能，分为两种方式：邻接矩阵法和邻接表法。实现图的建立，结点插入，删取得第一个邻接点,取得下一个邻接点,取得第i个结点的名称,取得边（v1，v2）的权值,插入边,插入点,删除边,删除点,取得结点v的位置,输出等功能
新建 DOC 文档_实现图的邻接矩阵和邻接表存储_doc_图的遍历算法_
10-01
领会图的两种主要存储结构、图基本运算算法和两种遍历算法设计内容：编写一个程序，设计带权图的邻接矩阵与邻接表的创建和输出运算，并在此基础上设计一个主程序完成如下功能：（1）建立如图所示的有向图G的邻接矩阵...
【数据结构与算法】图的概念，邻接矩阵，邻接表的实现
黄骏捷的博客
05-30 501
图的定义 是由顶点的有穷非空集合和顶点之间边的集合组成，通过常表示为：G(V,E)，其中G表示一个图，V是图G中顶点的集合，E是图G中边的集合。 无向边，无向图： 若顶点Vi 到Vj之间的边没有方向，则称这条边为无向边，用无序偶对（Vi,Vj）来表示,因为无向，也可以写成（Vj,Vi）。 如果图中任意两个顶点之间都是无向边，则称该图为无向图。 该无向图G1可表示为：G1=(V1{E1}) 其中顶...
数据结构 - 图（邻接矩阵、邻接表）
it_lihongmin的博客
03-09 4177
目录 1、图的概念 2、图的表示方式 1)、邻接矩阵 2)、邻接表 图是除了树之外的另一大类非线性表数据结构，应对到现实生活中有大量的应用，比如微博、微信、QQ等怎么表示其好友关系，关注、被关注（粉丝），亲密度等；地图出行，怎么查询到一个地方的最近距离，这些问题抽象算法都依赖底层的数据结构图。现在除了非关系型数据库、关系型数据库，还有图数据库抽象存储更复杂的现实模型。上面都没有图来的直接，先上图吧. 1、图的概念 树种的节点类比到图中叫顶点（Vertex），如上图中的A；顶...
图的存储结构(邻接矩阵与邻接表)及其C++实现
weixin_33713503的博客
01-07 848
一、图的定义 图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为： 　　　　　　　　　　　　　　　　　　　G=(V，E) 其中：G表示一个图，V是图G中顶点的集合，E是图G中顶点之间边的集合。 注： 在线性表中，元素个数可以为零，称为空表； 在树中，结点个数可以为零，称为空树； 在图中，顶点个数不能为零，但可以没有边。 二、图的基本术语 略。 三、图的遍历 　　图的...
数据结构之邻接表与邻接矩阵
sanqianjia的博客
04-16 946
无向图 1.1邻接表 （找出每个顶点相邻的顶点） 1.2邻接矩阵 （两顶点若连接，则为1，反之为0） 有向图 2.1邻接表 （找每个顶点相邻，且以此顶点为起始点。以3为例，与3相邻的顶点有1，2，4，5，找以3为起始顶点的，则只有1，5） 2.2邻接矩阵 ...
数据结构——邻接矩阵/邻接表
Yawn
07-20 4803
1. 图 图是一种非线性数据结构，由「节点（顶点）vertex」和「边 edge」组成，每条边连接一对顶点。根据边的方向有无，图可分为「有向图」和「无向图」。本文 以无向图为例开展介绍。 如下图所示，此无向图的 顶点 和 边 集合分别为： 顶点集合： vertices = {1, 2, 3, 4, 5} 边集合： edges = {(1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (3, 5), (4, 5)} 表示图的方法通常有两种： 邻接矩阵 邻接表 2. 邻接矩阵
邻接矩阵和邻接表
热门推荐
ZER00000001的博客
06-14 1万+
图的概述和存储结构（一）有一种说法是程序是由数据结构和算法组成的，这很能体现出数据结构在编码中的重要性。而代码优化的能力也是区别有基础的程序员和码农的重要标准，所以对于这一块的学习一定要稳重与细致，每一个章节都要实打实敲出能够实现该种结构的代码才算完成。数据结构的学习本质上是让我们能见到很多前辈在解决一些要求时间和空间的难点问题上设计出的一系列解决方法，我们可以在今后借鉴这些方法，也可以根据这些方法在遇到具体的新问题时提出自己的解决方法。（所以各种定义等字眼就不用过度深究啦，每个人的表达方式不一样而已）在此
数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历
10-07
在压缩包文件"数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历_1602077415"中，包含了关于这些主题的详细资料，可能包括理论解释、代码示例和练习题，帮助读者深入理解和掌握图的存储...
数据结构：图（邻接矩阵法）
Blog
01-12 743
package Graph; import java.io.IOException; import java.util.Queue; import java.util.Scanner; class GraphNode{ int data; } public class Graph { GraphNode vexs[]=new GraphNode[100]; //图的结点表 int[][...
构建有向图邻接表
weixin_30237281的博客
07-03 2044
建立一个有向图的邻接表，首先要构思好它的邻接表里面包含哪些结构数据，然后根据哪些数据来建立相应的结构体。但也要注意数据的输入。 #include <stdio.h> #include <stdlib.h> #define MAX_SIZE 10 typedef struct ArcNode //弧节点结构体 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值