精华内容
下载资源
问答
  • 有向图邻接矩阵c++运算操作 基本操作 邻接矩阵 c++实现
  • C# 有向 邻接矩阵 实现路径查询 查询两点间的所有路径
  • 根据邻接矩阵“mAdj”返回稀疏关联矩阵“mInc”。 关联矩阵中的边排序是根据从第一个顶点开始的顶点的相邻边的顺序,即第一条边与第一个顶点重合,下一条边与第二个顶点重合,等等。 如果是有向的,关联矩阵 mInc ...
  • 这是对于无向图邻接矩阵的算法描述,对于理解邻接矩阵是非常有用的,特别是初学者,相信它能够帮到你
  • 主要介绍了python使用邻接矩阵构造代码示例,具有一定参考价值,需要的朋友可以了解下。
  • 仅限学习使用 个人资料整理 数学与计算机学院 课程设计说明书 数据结构与算法课程设计名 称: 课程 : 6014389 码程 代 课 目: 无向邻接矩阵存储结构题 4班 级软件年级专业班: 2018// 名: 吴超学 生 姓 号: ...
  • 博文测试代码,博文链接:https://blog.csdn.net/qq_44075108/article/details/116085013
  • 代码思路:练习题6-1 有向图邻接矩阵转换为邻接表 (10 分) 1.邻接矩阵的数据类型描述: #define MAXVEX 20 typedef char Vextype; typedef struct { int arcs[MAXVEX+1][MAXVEX+1]; Vextype vex[MAXVEX+1]; int ...

    1.邻接矩阵的数据类型描述:

    #define MAXVEX 20
    typedef char Vextype;
    typedef struct
    {
        int arcs[MAXVEX+1][MAXVEX+1];
        Vextype vex[MAXVEX+1];
        int vexnum;
        int arcnum;
    }AdjMatrix;
    

    2.邻接链表的数据类型定义:

    typedef struct ArcNode
    {
        int adjvex;
        struct ArcNode *next;
    }ArcNode;
    typedef struct 
    {
        Vextype vexdata;
        ArcNode *head;
    }VertexNode;
    typedef struct
    {
        VertexNode vertex[MAXVEX];
        int vexnum;
        int arcnum;
    }AdjList;
    

    3.代码思路:

    先将临界矩阵与邻接链表的顶点数目与边数目置为相等;
    建立指向邻接链表的指针s,p;建立双重循环判断邻接矩阵中的arce[i][j]中的是否为1(1是图中没有带权值,且其对应的顶点之间有关系)再将矩阵中对应顶点关系的下标值赋值给邻接矩阵中的s所指的下标值。令p=vertex[i].head;
    判断p是否为空,如果为空的话讲s赋值给p,若不为空将s中的值插到p的后面。

    练习题6-1 有向图邻接矩阵转换为邻接表 (10 分)

    编写算法实现将有向图的邻接矩阵转换为邻接表
    输入说明:

    第一行,输入顶点总数n

    第二行,连续输入n个字符,无间隔,依次为各个顶点的信息

    第三行,输入弧总数e

    第四行,连续输入e条弧,例如:<A,B>
    输出说明

    依照顶点顺序输出各个顶点的邻接表,每个顶点一行。

    每行先输出顶点序号,顶点信息,然后依次输出各个邻接点的编号(注意:各邻接点按顶点序号升序排列),详见输出样例。
    裁判测试程序样例:

    #include<stdio.h> 
    #include<stdlib.h> 
    
    
    void Creat_AdjMatrix(AdjMatrix *G);  //创建邻接矩阵
    int LocateVex_AdjMatrix(AdjMatrix *G,Vextype v);  
    
    void Print_AdjList(AdjList *G);  //输出邻接表
    
    void AdjMatrixToAdjList(AdjMatrix *M,AdjList *L);  //邻接矩阵转换为邻接表
    
    main()
    {
        AdjMatrix gM;
        AdjList gL;
        Creat_AdjMatrix(&gM);
        AdjMatrixToAdjList(&gM,&gL);
        Print_AdjList(&gL);
    }
    
    void Creat_AdjMatrix(AdjMatrix *G)//创建邻接矩阵
    {
        int i,j,k;
        char v1,v2;
        scanf("%d\n",&(G->vexnum));
        for(i=1;i<=G->vexnum;i++)
        { 
            scanf("%c",&(G->vex[i]));
            for(j=1;j<=G->vexnum;j++)
                G->arcs[i][j]=0;
        }
        scanf("%d\n",&(G->arcnum));
        for(k=1;k<=G->arcnum;k++)
        {
            scanf("<%c,%c>",&v1,&v2);
            i=LocateVex_AdjMatrix(G,v1);
            j=LocateVex_AdjMatrix(G,v2);
            G->arcs[i][j]=1; 
        }
    }
    
    int LocateVex_AdjMatrix(AdjMatrix *G,Vextype v)//输出邻接表
    {
        int i;
        for(i=1;i<=G->vexnum;i++)
            if(G->vex[i]==v) 
                return i;
        return 0;
    }
    
    
    void Print_AdjList(AdjList *G)
    {
        int i;
        ArcNode *p;
        for(i=1;i<=G->vexnum;i++)
        { 
            printf("%d:(%c)",i,G->vertex[i].vexdata);
            for(p=G->vertex[i].head;p;p=p->next)
            {
                printf("->%d",p->adjvex);
            }
            printf("\n");
        }
    }
    
    /* 请在这里填写答案 */
    

    输入样例:

    5
    abcde
    7
    <a,b><b,c><c,d><d,a><d,b><a,e><e,c>
    结尾无空行
    

    输出样例:

    1:(a)->2->5
    2:(b)->3
    3:(c)->4
    4:(d)->1->2
    5:(e)->3
    结尾无空行
    

    代码实现:

    void AdjMatrixToAdjList(AdjMatrix *M,AdjList *L){
     L->vexnum=M->vexnum; 
     L->arcnum=M->arcnum;
     int i,j;
     ArcNode *p,*s;
     for(i=1;i<=L->vexnum;i++){
      L->vertex[i].vexdata=M->vex[i];
      L->vertex[i].head=NULL;
     }
     for(i=1;i<=M->vexnum;i++){
      for(j=1;j<=M->vexnum;j++){
       if(M->arcs[i][j]==1){
        s=(ArcNode*)malloc(sizeof(ArcNode));
        s->adjvex=j;
        s->next=NULL;
        p=L->vertex[i].head;
        if(p==NULL) 
        {
         L->vertex[i].head=s;
        }
        else{
         while(p->next)
          p=p->next;
         s->next=p->next;
         p->next=s;
        }
       }
      }
     }
    } 
    
    展开全文
  • 主要介绍了Java编程实现邻接矩阵表示稠密代码示例,具有一定参考价值,需要的朋友可以了解下。
  • C语言无向图邻接矩阵

    2021-05-15 19:53:04
    } /* *采用邻接矩阵表示法构造无向 */ void CreateMGraph(Mgraph *G) { int i, j, k, w; // 顶点 char v1, v2; printf("请输入要创建的的顶点数和边数(以空格隔开)\n"); scanf("%d %d", &(G->vexnum), &(G->...

    参考了课本和博客园上的某篇博客,感谢!

    #include<stdio.h>
    
    #include<stdlib.h>
    
    /* 最大顶点数 */
    #define Max_Vertex_Num 100
    
    #define isLetter(a)  ((((a)>='a')&&((a)<='z')) || (((a)>='A')&&((a)<='Z')))
    
    
    
    /*
    
    arcs[i][j] = 1,表示 "顶点i (即 vexs[i] )" 和 "顶点j (即 vexs[j] )" 是邻接点;
    
    arcs[i][j] = 0,表示它们不是邻接点。
    
    */
    
    typedef struct{
    
        // 顶点集合,用于保存顶点
        char vexs[Max_Vertex_Num];
    
        // 邻接矩阵
        int arcs[Max_Vertex_Num][Max_Vertex_Num];
    
        //顶点数
        int vexnum;
    
        //边数
        int arcnum;
    
    }Mgraph;
    
    
    
    
    /*
     * 读取一个输入字符
     */
    static char read_char()
    {
        char ch;
    
        do {
    
            ch = getchar();
    
        } while(!isLetter(ch));
    
        return ch;
    }
    
    
    
    /*
     *查找图中顶点的位置(数组中的下标)
     */
    int LocateVex(Mgraph *G, char u)
    {
        int i;
    
        for(i = 0; i < G->vexnum; ++i)
    
            if(G->vexs[i] == u)
            {
                return i;
            }
    
        return -1;
    }
    
    
    
    
    /*
     *采用邻接矩阵表示法构造无向图
     */
    void CreateMGraph(Mgraph *G)
    {
    
        int i, j, k, w;
    
        // 顶点
        char v1, v2;
    
    
        printf("请输入要创建的图的顶点数和边数(以空格隔开)\n");
    
        scanf("%d %d", &(G->vexnum), &(G->arcnum));
    
        if ( G->vexnum < 1 || G->arcnum < 1 || (G->arcnum > (G->vexnum * (G->vexnum - 1)) / 2 ) )
        {
            printf("输入错误: 无向图的顶点数或边数无效!\n");
            exit(0);
        }
    
    
        printf("\n请输入要创建的顶点信息:\n");
    
        for(i = 0; i < G->vexnum; i++)
        {
             G->vexs[i] = read_char();
        }
    
    
        // 初始化邻接矩阵
        for(i = 0; i < G->vexnum; i++)
    
            for(j = 0; j < G->vexnum; j++)
    
                G->arcs[i][j] = 0;
    
    
        printf("\n\n请输入要创建的每条边对应的两个顶点及权值w:\n");
    
        for(k = 0;k < G->arcnum; k++)
        {
            printf("\n输入顶点1:");
    
            v1 = read_char();
    
            printf("输入顶点2:");
    
            v2 = read_char();
    
            printf("输入边的权值w:");
    
            scanf("%d", &w);
    
            // 查找顶点v1、v2在图中的位置
            // 即在顶点向量中的下标
            i = LocateVex(G, v1);
    
            j = LocateVex(G, v2);
    
            if((i == -1 || j == -1))
            {
                printf("\n该边无效,请重新输入\n");
            }
            else
            {
                G->arcs[i][j] = w;
                G->arcs[j][i] = w;
    
            }
        }
    }
    
    
    
    /*
     * 打印矩阵队列图
     */
    void print_graph(Mgraph G)
    {
        int i, j;
    
        printf("\n\n无向图邻接矩阵:\n");
        for (i = 0; i < G.vexnum; i++)
        {
            for (j = 0; j < G.vexnum; j++)
    
                printf("%d ", G.arcs[i][j]);
    
            printf("\n");
        }
    }
    
    
    
    
    int main()
    {
        Mgraph g;
    
        CreateMGraph(&g);
    
        print_graph(g);
    
        return 0;
    }
    
    
    
    
    
    

     

    展开全文
  • 一次上机练习——有向邻接矩阵转化为邻接表并存储顶点大于50的值 小渣渣写的和大家一起学习进步
  • //邻接矩阵表示 typedef struct{ int e_num; //边数 int v_num; //顶点个数 int links[SIZE][SIZE]; //邻接矩阵 char vexs[SIZE]; }Graph1; //邻接表表示 typedef struct edgeNode{ //边节点 char vex; int ...
    #define SIZE 10
    
    //邻接矩阵表示
    typedef struct{
        int e_num;  //边数
        int v_num;  //顶点个数
        int links[SIZE][SIZE];   //邻接矩阵
        char vexs[SIZE];
    }Graph1;
    
    //邻接表表示
    typedef struct edgeNode{    //边节点
        char vex;
        int value;
        struct edgeNode *next;
    }edgeNode;
    
    typedef struct vexNode{     //顶点节点
        char data;
        edgeNode *firstNode;
    }Vexs[SIZE];
    
    typedef struct{             //图
        int e_num;  //边数
        int v_num;  //顶点个数
        Vexs vex_arcs; //邻接表
    }Graph2;
    
    
    void trans(Graph1 *p, Graph2 *q){
    
        q->e_num = p->e_num;
        q->v_num = p->v_num;
    
        int i,j;
        for(i=0; i<p->v_num; i++){
            q->vex_arcs[i].data = p->vexs[i];
            q->vex_arcs[i].firstNode = NULL;
            
            for(j=0; j<p->v_num; j++){
                if(p->links[i][j] != 0){
                	//头插法
                    edgeNode *new = (edgeNode *)malloc(sizeof(edgeNode));
                    new->vex = p->vexs[j];
                    new->next = q->vex_arcs[i].firstNode;
                    q->vex_arcs[i].firstNode = new;
                    
                }
            }
        }
    }
    

    在这里插入图片描述

    展开全文
  • 邻接矩阵储存无向

    2018-09-01 17:06:04
    采用邻接矩阵实现无向的存储,并输入输出邻接矩阵。实现的广度优先遍历和深度优先遍历。
  • 输出有向图邻接矩阵

    千次阅读 2021-11-13 18:13:40
    【问题描述】设存在有向G,输入顶点数n,边数为m,输入边信息,输出其对应的邻接矩阵。 【输入形式】首先输入顶点个数n(小于10),顶点名称依次为0至n-1;输入边数m;输入顶点之间的边(两个顶点之间用空格隔开...

    【问题描述】设存在有向图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:注意到输入的遍没有按照二位矩阵双循环的方式判断,故选择输入一次边,调用一次遍历

    #include<cstdio>
    #include<iostream>
    using namespace std;
    int a[10][10] = { 0 };
    
    int main(){
    	int n ,m;
    	int i ,j;
    	cin >> n;
    	cin>> m;			//输入点数 和 边数
    	int p, q;
    	
    	for (int k = 0; k < m; k++)       // 有m条边 需要输入(判断)m次边数     
    	{
    		cin >> p >> q;                
    		for (i = 0; i < n; i++)       
         //输入的边和矩阵顺序无关 需要输入一次边信息 调用一次双循环遍历
    		{
    			for (j = 0; j < n; j++)
    			{
    
    				if (p == i && q == j)  
    					a[i][j] = 1;       //若找到 则赋值为1
    			}
    		}
    		
    	}
    	for (i = 0; i < n; i++)            //输出矩阵 
    	{
    		for (j = 0; j < n; j++)
    		{
    			cout << a[i][j] << " ";
    		}
    		cout << endl;
    	}
    
    
    
    	return 0;
    }

    展开全文
  • package Graph; import java.io.File; import java.io.FileNotFoundException; import java.util.Scanner; public class AdjMatrix { ... //邻接矩阵 public AdjMatrix(String fileName) { File f
  • Python语言,用邻接矩阵实现 通过二维数组建立无向 通过二维数组建立有向 通过边建立有向 为方便查看,通过NetworkX显示
  • 已知邻接矩阵,求可达矩阵的MATLAB代码
  • 无向图邻接矩阵的创建代码实现完整代码如下程序结果 根据的定义,邻接矩阵的存储需要对顶点和边分别存储。而邻接矩阵表示法是一个用一维数组存储顶点信息,用二维数组存储边(弧)的信息。实现这个算法首先要...
  • 图邻接矩阵的N次幂意义

    千次阅读 2021-04-01 16:26:47
    设A(n x n)为一个邻接矩阵,则a(i,j)表示两个点之间是否连通(1:连通,0:不连通)。那么A的k次方中的每一个a(i,j)表示点i和j之间长度为k的路的条数。假设一个能划分成若干个子,每个子图之间不相连,...
  • 这里有一点一定要注意,因为为无向,因此邻接矩阵一定要是关于对角线对称的,即Aij=Aji(且对角线上元素Aii=0),两点之间相互无向连接,有向可以不为对称矩阵(有方向) 方法及函数: 1.推荐matlab一个图论很...
  • 数据结构:无向图邻接矩阵转换为邻接表

    千次阅读 多人点赞 2020-02-15 18:20:10
    无向图邻接矩阵转换为邻接表 代码如下(C): #include <stdio.h> #include<stdlib.h> #define MAXV 100 //以下定义邻接矩阵类型 typedef struct { int vexs[MAXV]; int arcs[MAXV]...
  • 使用邻接矩阵法实现,包含如下操作: 1. 创建; 2. 销毁; 3. 清空; 4. 加入边; 5. 删除边; 6. 获取权; 7. 获取结点的度; 8. 获取的结点数; 9. 获取的边数。
  • //数值类型 整型//创建有向图邻接矩阵//把邻接矩阵转换成临界表//把值大于50的顶点保存在单链表中//输出邻接矩阵,临界表,大于50的结点#include&lt;stdio.h&gt;#include&lt;malloc.h&gt;#define ...
  • 不能保证能各个节点之间能完全走通,只是记录一下。... 构建无向图邻接矩阵 :param n: 矩阵是 n x n 状的 :param low: 矩阵中每个位置数值的大小下限 :param high: 矩阵中每个位置数值的大小上限 :param num_base:
  • GPLOTDC 绘制有向GPLOTDC(A,XY) 使用下面描述的默认样式绘制由邻接矩阵 A 和点 xy 表示的有向GPLOTDC(A,XY,PARAM1,VAL1,PARAM2,VAL2,...) 使用有效的参数名称/值对绘制有向 输入: A - NxN 邻接矩阵,其中 A(I...
  • 无向图邻接矩阵转邻接表,邻接表转邻接矩阵

    千次阅读 多人点赞 2018-06-19 14:19:26
    //邻接矩阵类型 //以下定义邻接表类型 typedef struct ANode //边的节点结构类型 { int adjvex; //该边的终点位置 struct ANode *nextarc; //指向下一条边的指针 InfoType info; //该边的相关信息,这里用于...
  • 的实现:邻接矩阵

    2014-07-31 21:18:49
    使用邻接矩阵实现结构,无论是有向、无向、带权还是无权,都可以指定。
  • Java无向图邻接矩阵的实现

    千次阅读 2019-08-30 15:04:14
    上面的G包含了"A,B,C,D,E,F,G,H,I"共9个顶点,而且包含了"(A,C),(A,D),(A,F),(B,C),(C,D),(E,G),(F,G),(H.I)...上右边的矩阵是G在内存中的邻接矩阵示意。A[i][j]=1表示第i个顶点与第j个顶点是邻接点,A[i][j]=...
  • 刚开始不理解邻接矩阵幂的含义,虽然知道幂次代表长度 l(可以理解为步数或者跳数),但就是不理解 aij 代表长度 为 l 的通路数,直到手算了一下 A的 l 次方才理解。 下面是理解的结果 这涉及到矩阵的乘法 知道最...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 72,005
精华内容 28,802
关键字:

图的邻接矩阵

友情链接: sniff_docs2.zip