精华内容
下载资源
问答
  • C语言无向图邻接矩阵
    2021-05-15 19:53:04

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

    #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;
    }
    
    
    
    
    
    

     

    更多相关内容
  • MATLAB源码集锦-无向图关联矩阵和邻接矩阵的相互转换算法代码
  • 仅限学习使用 个人资料整理 数学与计算机学院 课程设计说明书 数据结构与算法课程设计名 称: 课程 : 6014389 码程 代 课 目: 无向图邻接矩阵存储结构题 4班 级软件年级专业班: 2018// 名: 吴超学 生 姓 号: ...
  • 输出途径站点和换乘情况
  • //邻接矩阵表示 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;
                    
                }
            }
        }
    }
    

    在这里插入图片描述

    展开全文
  • 利用Java构建无向图邻接矩阵

    千次阅读 2020-05-09 23:48:45
    package Graph; import java.io.File; import java.io.FileNotFoundException; import java.util.Scanner; public class AdjMatrix { ... //邻接矩阵 public AdjMatrix(String fileName) { File f
    package Graph;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.util.Scanner;
    
    public class AdjMatrix {
    	private int V;    //顶点个数
    	private int E;    //边的个数
    	private int[][] adj;  //邻接矩阵
    	
    	public AdjMatrix(String fileName) {
    		File file=new File(fileName);
    		try {
    			Scanner scanner=new Scanner(file);
    			V=scanner.nextInt();
    			adj=new int[V][V];
    			E=scanner.nextInt();
    			for(int i=0;i<E;i++) {
    				int a=scanner.nextInt();
    				int b=scanner.nextInt();
    				//数组相应位置处有顶点之间连接的赋值为1
    				adj[a][b]=1;  
    				adj[b][a]=1;
    				
    			}
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    	
    	@Override
    	public String toString() {
    		StringBuilder sb=new StringBuilder();
    		sb.append(String.format("V = %d,E = %d\n",V,E));
    		for(int i=0;i<V;i++) {
    			for(int j=0;j<V;j++) {
    				sb.append(String.format("%d\t", adj[i][j]));
    			}
    			sb.append('\n');
    		}
    		return sb.toString();
    	}
    	
    	public static void main(String[] args) {
    		AdjMatrix adj=new AdjMatrix("graph.txt");
    		System.out.println(adj);
    	}
    }
    

    得到的邻接矩阵如下所示:

    V = 7,E = 9
    0	1	0	1	0	0	0	
    1	0	1	0	0	0	1	
    0	1	0	1	0	1	0	
    1	0	1	0	1	0	0	
    0	0	0	1	0	1	0	
    0	0	1	0	1	0	1	
    0	1	0	0	0	1	0	
    

    其中.txt文件中存储着无向图中的顶点个数、边的个数以及各个顶点之间的连接关系,如下所示
    在这里插入图片描述
    该案例中的无向图如下:
    在这里插入图片描述

    展开全文
  • 数据结构:无向图邻接矩阵转换为邻接表

    千次阅读 多人点赞 2020-02-15 18:20:10
    无向图邻接矩阵转换为邻接表 代码如下(C): #include <stdio.h> #include<stdlib.h> #define MAXV 100 //以下定义邻接矩阵类型 typedef struct { int vexs[MAXV]; int arcs[MAXV]...

    无向图邻接矩阵转换为邻接表

    代码如下(C):

    #include <stdio.h>
    #include<stdlib.h>
    #define MAXV 100                
    //以下定义邻接矩阵类型  
    typedef struct                  
    {
    	int vexs[MAXV];      		 
        int arcs[MAXV][MAXV];       
        int vexnum,arcnum;          
    } MGraph;                       
    //以下定义邻接表类型
    typedef struct ANode            
    {
        int adjvex;                 
        struct ANode *nextarc;        
    } ArcNode;
    typedef struct Vnode           
    {
        int data;                
        ArcNode *firstarc;         
    } VNode;
    typedef struct
    {
        VNode vertices[MAXV];            
        int vexnum,arcnum;               
    } ALGraph;                      
    void MatToList(MGraph g,ALGraph *&G)
    //将邻接矩阵g转换成邻接表G
    {
        int i,j;
        ArcNode *p,*s;
        G=(ALGraph *)malloc(sizeof(ALGraph));
        for (i=0; i<g.vexnum; i++)             
            G->vertices[i].firstarc=NULL;
        for (i=0; i<g.vexnum; i++)    
            for (j=0; j<g.vexnum; j++)
                if (g.arcs[i][j]!=0) 
                {
    	 			p=(ArcNode *)malloc(sizeof(ArcNode)); 
    	            p->adjvex=j; p->nextarc=NULL;
    				if(!G->vertices[i].firstarc)
    					G->vertices[i].firstarc=p;
    				else{
    					s=G->vertices[i].firstarc;
    					while(s->nextarc) s=s->nextarc;
    					s->nextarc=p;
    				}
                }
        G->vexnum=g.vexnum;
        G->arcnum=g.arcnum;
    }
    void Output(ALGraph *G)
    //输出邻接表G
    {
        int i;
        ArcNode *p;
        for (i=0; i<G->vexnum; i++)
        {
            p=G->vertices[i].firstarc;
            printf("v%d:",i+1);
            while (p!=NULL)
            {
                printf("%2d",p->adjvex);
                p=p->nextarc;
            }
            printf("\n");
        }
    }
    int main()
    {
        int i,j;
        MGraph g;//定义图的邻接矩阵 
        ALGraph *G;//邻接表 
        int n,m;
        printf("输入图G的邻接矩阵顶点数:\n");
        scanf("%d",&n);
        printf("输入图G的邻接矩阵边数:\n");
        scanf("%d",&m);
        int A[n][n];//邻接矩阵 
        printf("输入图G的邻接矩阵:\n");
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<n; j++)
            {
            	scanf("%d",&A[i][j]);
            }
        }
        g.vexnum=n;
        for (i=0; i<g.vexnum; i++)
            for (j=0; j<g.vexnum; j++)
                g.arcs[i][j]=A[i][j];
        printf("图G的邻接矩阵转换成邻接表:\n");
        MatToList(g,G);
        Output(G);
        return 0;
    }
    

    运行结果:
    在这里插入图片描述
    欢迎大家关注我

    展开全文
  • Prim算法计算最小生成树(无向图&邻接矩阵)——C语言实现。
  • 无向图邻接矩阵的建立,难度不大,源码如下: #include&amp;lt;iostream&amp;gt; using namespace std; typedef struct { char nodes[100];//顶点表 int arcs[100][100];//边表 邻接矩阵 相邻接为...
  • 邻接矩阵构造无向图、网,有向图、网,在各版本vs下可运行
  • 主要介绍了Python根据已知邻接矩阵绘制无向图操作,涉及Python使用networkx、matplotlib进行数值运算与图形绘制相关操作技巧,需要的朋友可以参考下
  • 无向图邻接矩阵转邻接表,邻接表转邻接矩阵

    千次阅读 多人点赞 2018-06-19 14:19:26
    ///printf(" 有向图G的邻接矩阵:\n"); //DispMat(g); G=new ALGraph; //printf(" 图G的邻接矩阵转换成邻接表:\n"); MatToList(g,G); DispAdj(G); /* printf(" 图G的邻接表转换成邻接邻阵:\n"); for (i=0;i;i...
  • 这是对于无向图邻接矩阵的算法描述,对于理解邻接矩阵是非常有用的,特别是初学者,相信它能够帮到你
  • python程序实现:输入邻接矩阵,输出对应无向图/有向图。 运用了networkx、matplotlib模块,感兴趣可以下载学习,可通过pycharm实现。
  • 这里有一点一定要注意,因为为无向图,因此邻接矩阵一定要是关于对角线对称的,即Aij=Aji(且对角线上元素Aii=0),两点之间相互无向连接,有向图可以不为对称矩阵(有方向) 方法及函数: 1.推荐matlab一个图论很...
  • Python语言,用邻接矩阵实现图 通过二维数组建立无向图 通过二维数组建立有向图 通过边建立有向图 为方便查看,通过NetworkX显示图。
  • 不能保证能各个节点之间能完全走通,只是记录一下。... 构建无向图邻接矩阵 :param n: 矩阵是 n x n 状的 :param low: 矩阵中每个位置数值的大小下限 :param high: 矩阵中每个位置数值的大小上限 :param num_base:
  • 无向图邻接矩阵的创建

    万次阅读 多人点赞 2019-01-29 16:00:49
    无向图邻接矩阵:存储方式是利用两个数组来表示图。一个一维数组(Vexs)存储图中顶点信息,另一个二维数组(Edge)存储图中边的信息。 首先创建邻接矩阵的结构体,变量有存放顶点信息的一维数组(Vexs),存放边...
  • 问题描述使用邻接矩阵存储下图所示无向图**** 解题思路创建一个邻接矩阵程序实现#include #include #define MAXVEX 10/* Status是函数的类型,其值是函数结果状态代码,如OK等 */typedef int Status;/* 顶点类型应由...
  • 无向图邻接矩阵转化为邻接表

    千次阅读 2020-09-25 15:36:59
    typedef struct { int vertex[max]; int arc[max][max]; int vexnum,aecnum; }MGraph; typedef struct ArcNode{ int adjvex; struct ArcNode *next; }ArcNode; typedef struct VNode ... AdjList ver.
  • 无向图邻接矩阵(C++)

    千次阅读 2021-10-29 22:40:29
    用一个二维数组存放顶点间关系(边或弧)的数据,这个二维数组称为邻接矩阵。 完整代码: #include <iostream> using namespace std; #define Maxint 999 #define MVNum 100 //定义数据结构 typedef ...
  • #include<stdio.h> #include<stdlib.h> #define MAXSIZE 20 ...void CreatMGraph(MGraph* g, int e, int n)//建立邻接矩阵 n为顶点数,e为边数 { int i, j, k; printf("input data of vertaxs\n.
  • 您可以从邻接矩阵表示转换的图形,以基于节点的表示像这样:#include #include using namespace std;const int adjmatrix[9][9] = {{0,1,0,0,1,0,0,0,0},{1,0,1,0,0,0,0,0,0},{0,1,0,1,0,0,0,0,0},{0,0,1,0,0,1,0,0,...
  • 将一个无向图邻接矩阵转换为邻接表 什么是无向图? 图是一种基本的数据结构,在离散数学中有详细介绍过。 邻接矩阵? 图的邻接矩阵(Adjacency Matrix)存储方式是用两个数组来表示图。一个一维的数组存储图中顶点...
  • 无向图邻接矩阵(数组表示法)

    千次阅读 2021-10-30 08:39:07
    图的逻辑结构:多对多 很难用多重链表表示 1.数组(邻接矩阵)表示法 ...一维数组Vexs[n],叫顶点表,有n个,所以定义从0到n-1的数组,将n个顶点存储。...用二维数组arcs(边的 ...来看无向图的例子:这个邻接矩阵...
  • 邻接矩阵 介绍 邻接矩阵存储结构就每个顶点用一个最大值为n的一维数组存储边的信息,这样所有点合起来就是用矩阵表示图中...无向图邻接矩阵的第i行(或第i列)非零元素的个数正好是第i个顶点的度。 有向图邻接矩阵中第i
  • 数据结构——无向图(邻接矩阵表示) */ #include<iostream> #include<queue> #define maxsize 100 using namespace std; typedef struct { char vex[maxsize]; int va[maxsize][maxsize]; }Graph; .
  • 无向图邻接矩阵 通过用邻接矩阵来表示无向图。如下无向图G1的邻接矩阵无向图G1包含了“A, B, C, D, E, F, G”共七个顶点,而且包含了“(A, C), (A, D), (A, F), (B, C), (C, D), (E, G), (F, G)”共七条边。...
  • Java无向图邻接矩阵的实现

    千次阅读 2019-08-30 15:04:14
    G是无向图,因此边(A,C)和边(C,A)是同一条边;这里列举边时,是按照字母先后顺序列举的。 上图右边的矩阵是G在内存中的邻接矩阵示意图。A[i][j]=1表示第i个顶点与第j个顶点是邻接点,A[i][j]=...
  • 邻接矩阵-无向图.rar

    2020-04-23 18:11:51
    1.采用邻接矩阵实现无向图的存储,并输入输出邻接矩阵。求每个顶点的度,并实现图的广度优先遍历和深度优先遍历

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,405
精华内容 11,362
关键字:

无向图邻接矩阵