精华内容
下载资源
问答
  • 这是对于无向图邻接矩阵的算法描述,对于理解邻接矩阵是非常有用的,特别是初学者,相信它能够帮到你
  • 无向图邻接矩阵

    2014-11-25 10:47:35
    #include #include #define MAXSIZE 30 typedef struct{  char rertex[MAXSIZE]; ... int edges[MAXSIZE][MAXSIZE];...void CreatMGraph(MGraph *g,int e,int n){// 边 顶点  int k,i,j;  printf("Input
    #include<stdio.h>
    #include<stdlib.h>
    #define MAXSIZE 30
    typedef struct{
     char rertex[MAXSIZE];
     int edges[MAXSIZE][MAXSIZE];
    }MGraph;
    void CreatMGraph(MGraph *g,int e,int n){//图 边 顶点
     int k,i,j;
     printf("Input data of vertexs(0 ~ n-1):\n");
     for(i=0;i<n;i++)
      g->rertex[i]=i;       //读顶点  可自行输入
     for(i=0;i<n;i++)
      for(j=0;j<n;j++)
       g->edges[i][j]=0;
     for(k=0;k<e;k++)
     {
      printf("Input edges of(i,j):");
      scanf("%d,%d",&i,&j);
      g->edges[i][j]=1;
      g->edges[j][i]=1;   //删除此句则成有向表
     }
    }
    void main()
    {
     int n,e,i,j;
     MGraph *g;
     g=( MGraph *) malloc(sizeof(MGraph));
     printf("Input edges and vertexs:");
     scanf("%d%d",&e,&n);
     CreatMGraph(g,e,n);
     for(i=0;i<n;i++)
     {
      for(j=0;j<n;j++)
       printf("%d ",g->edges[i][j]);
      printf("\n");
     }
    }
    /*Input edges and vertexs:4 4
    Input data of vertexs(0 ~ n-1):
    Input edges of(i,j):0,1
    Input edges of(i,j):0,3
    Input edges of(i,j):1,3
    Input edges of(i,j):1,2
    0 1 0 1
    1 0 1 1
    0 1 0 0
    1 1 0 0
    Press any key to continue*/
    展开全文
  • 无向图邻接矩阵转换为邻接表 代码如下(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;
    }
    

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

    展开全文
  • //无向图邻接矩阵搜索遍历的程序代码 #include<stdio.h> //图的邻接矩阵类型定义 const int n=8; const int e=10; typedef char vextype; typedef int adjtype; typedef struct { vextype vexs[n]; adjtype ...
    //无向图邻接矩阵搜索遍历的程序代码
    #include<stdio.h>
    //图的邻接矩阵类型定义
    const int n=8;
    const int e=10;
    typedef char vextype;
    typedef int adjtype;
    typedef struct
    {
    	vextype vexs[n];
    	adjtype arcs[n][n];
    }graph;
    graph*g=new graph;
    void creatgraph();
    void dfsa(int);
    int visited[n];
    
    int main()
    {
    	creatgraph();
    	int i;
    	while(1)
    	{
    		for(i=0;i<n;i++)
    			visited[i]=0;
    		printf("输入出发点序号(0-7),输入-1结束:");
    		scanf("%d",&i);
    		if(i==-1) break;
    	    dfsa(i);
    	}
    }
    
    //建立无向图邻接矩阵
    void creatgraph()
    {
    	int i,j,k;
    	char ch;
    	printf("输入8个顶点的字符数据信息:\n");
    	for(i=0;i<n;i++)
    		if((ch=getchar())!='\n') g->vexs[i]=ch;
    	for(i=0;i<n;i++)
    		for(j=0;j<n;j++)
    			g->arcs[i][j]=0;
    	printf("输入10条边的起、终点i,j:\n"); 
    	for(k=0;k<e;k++)
    	{
    		scanf("%d,%d",&i,&j); //顶点序号从0开始
    		g->arcs[i][j]=g->arcs[j][i]=1;
    	}
    }
    
    //添加深度优先搜索遍历算法
    void dfsa(int i)
    {
    	int j;
    	printf("node:%c\n",g->vexs[i]);
    	visited[i]=1;
    	for(j=0;j<n;j++)
    	{
    		if((g->arcs[i][j]==1)&&(visited[j]==0))
    		{
    			dfsa(j);
    		}
    	}
    }
    
    

    深度优先算法,与先序遍历的思想类似
    附测试数据
    ABCDEFGH
    0,1
    0,2
    1,3
    1,4
    2,5
    2,6
    3,7
    4,7
    5,7
    6,7

    展开全文
  • 无向图邻接矩阵的建立,难度不大,源码如下: #include&amp;lt;iostream&amp;gt; using namespace std; typedef struct { char nodes[100];//顶点表 int arcs[100][100];//边表 邻接矩阵 相邻接为...

    无向图邻接矩阵的建立,难度不大,源码如下:

    #include<iostream>
    using namespace std;
    
    typedef struct
    {
    	char nodes[100];//顶点表
    	int arcs[100][100];//边表 邻接矩阵 相邻接为1 否则为0
    	int num_nodes,num_arcs;//顶点数和边数
    }MGraph;//以邻接矩阵存储的图类型
    
    void CreatGraph(MGraph *&G)
    {
    	cout<<"please enter num is nodes and arcs:";
    	cin>>G->num_nodes>>G->num_arcs;//输入顶点数和边数
    	cout<<"please enter name is each vertex:";
    	for(int i=0;i<G->num_nodes;i++)
    	{
    		char ch;
    		cin>>ch;
    		G->nodes[i]=ch;//输入顶点信息
    	}
    	for(int p=0;p<G->num_nodes;p++)
    	{
    		for(int q=0;q<G->num_nodes;q++)
    			G->arcs[p][q]=0;//给每个顶点初始化 为0没有邻接
    	}
    	cout<<"please enter the relationship between each vertex and the value:";
    	for(int j=0;j<G->num_arcs;j++)
    	{
    		int a,b,c;
    		cin>>a>>b>>c;
    		while(a==b)
    		{
    			cout<<"error!please enter again:";
    			cin>>a>>b;
    		}
    		G->arcs[a][b]=c;//输入邻接的边,赋值他们的关系
    	}
    }
    
    void display(MGraph *&G)//输出邻接矩阵
    {
    	for(int i=0;i<G->num_nodes;i++)
    	{
    		for(int j=0;j<G->num_nodes;j++)
    		{
    			cout<<G->arcs[i][j]<<" ";//输出邻接矩阵表
    		}
    		cout<<endl;
    	}
    }
    
    int main()
    {
    	MGraph *g=new MGraph;
    	CreatGraph(g);
    	display(g);
    	return 1;
    }
    
    展开全文
  • %% 无向图邻接矩阵和关联矩阵转换function w = incandadf(F,f)%F为输入无向图矩阵可以是邻接矩阵或关联矩阵%% 邻接矩阵转关联矩阵if f == 0 m = sum(sum(F))/2; n = size(F,1); w = zeros(n,m); k = 1; for i = 1:n ...
  • 无向图邻接矩阵的创建

    千次阅读 多人点赞 2019-01-29 16:00:49
    无向图邻接矩阵:存储方式是利用两个数组来表示图。一个一维数组(Vexs)存储图中顶点信息,另一个二维数组(Edge)存储图中边的信息。 首先创建邻接矩阵的结构体,变量有存放顶点信息的一维数组(Vexs),存放边...
  • 不能保证能各个节点之间能完全走通,只是记录一下。... 构建无向图邻接矩阵 :param n: 矩阵是 n x n 状的 :param low: 矩阵中每个位置数值的大小下限 :param high: 矩阵中每个位置数值的大小上限 :param num_base:
  • package Graph; import java.io.File; import java.io.FileNotFoundException; import java.util.Scanner; public class AdjMatrix { ... //邻接矩阵 public AdjMatrix(String fileName) { File f
  • 无向图邻接矩阵转邻接表,邻接表转邻接矩阵

    千次阅读 多人点赞 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...
  • 无向图邻接矩阵与关联矩阵的转换

    千次阅读 2011-04-14 21:33:00
    %% **********无向图邻接矩阵与关联矩阵的转换******************** % 输入参数:F 邻接矩阵或关联矩阵 f转换参数,0表示邻接矩阵转换为关联矩阵 // % 1表示关联矩阵转换为邻接矩阵 // ...
  • Java无向图邻接矩阵的实现

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

    千次阅读 2018-01-10 14:20:19
    题目:判断一个无向图是否为树。 输入: 第一行为正整数n,代表图中点的个数; 接下来n行,每行有n个数据,每个数据以空格分隔,代表邻接矩阵。 输出: 若为树,输出yes; 否则,输出no。  ...
  • #include int visited[Maxsize]; #define Maxsize 50 #define M 500//定义无穷数值为5000 //标记顶点是否被访问,1为访问,0为未访问 typedef struct { int vex[Maxsize];...//矩阵表 int numVertexes,numEdges;
  • k++) //读入e条边 这时为无向图 { cout读入边:"; cin>>i>>j; G->arcs[i][j]=1; G->arcs[j][i]=1; /* cout读入边和权值:"; //当为有权值的图时 int w; cin>>i>>j>>w; G->arcs[i][j]=w; G->...
  • 有向图不对称邻接矩阵无向图对称邻接矩阵 一个简单图实例 import numpy as np # 使用numpy编写的上述有向图的邻接矩阵如下: # 不对称邻接矩阵 A = np.matrix([ [0,1,0,0], [0,0,1,1], [0,1,0,0], [1,0,1,0]...
  • 无向图邻接矩阵存储及输出无向图邻接矩阵存储及输出
  • 邻接矩阵储存无向图

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

    千次阅读 2016-12-03 09:16:52
    1.无向图邻接矩阵表示法验证程序  采用邻接矩阵表示无向图,完成图的创建、图的深度优先遍历、图的广度优先遍历操作。其中图的顶点信息是字符型,图中顶点序号按字符顺序排列。本输入样例中所用的图如下所示...
  • 无向图邻接矩阵表示
  • %% 无向图邻接矩阵和关联矩阵转换function w = incandadf(F,f)%F为输入无向图矩阵可以是邻接矩阵或关联矩阵%% 邻接矩阵转关联矩阵if f == 0 m = sum(sum(F))/2; n = size(F,1); w = zeros(n,m); k = 1; for i = 1:n ...
  • *顺序储存无向图邻接矩阵 *定义一个边的权值的二维数组 *定义一个点的一维数组 初始化 *创建一个无向图 *输出无向图的邻接矩阵 */ #include<stdio.h> #include<string.h> #include<stdlib.h> #...
  • 无向图邻接矩阵存储

    千次阅读 2017-07-27 14:37:22
    无向图邻接矩阵存储
  • 邻接矩阵无向图

    千次阅读 2017-12-29 21:15:58
    无向图和有向图在邻接矩阵中的表示方法:  无向图和有向图大同小异,在这里只以无向图为例,代码部分通过简单调整即可对应编译有向图 邻接矩阵数据类型定义 #define MaxVertices 100 //定义最大容量 ...
  • 无向图邻接矩阵基本操作

    千次阅读 2016-07-20 21:21:24
    无向图邻接矩阵基本操作
  • 无向图邻接矩阵

    千次阅读 2018-09-17 10:01:26
    public class MatrixDG {//无向图邻接矩阵 private char[] mVexs;//顶点集合 private int[][] mMatrix;//矩阵 public MatrixDG(char[] vexs, char[][] edges){//顶点数组,边数组 int vlen...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,485
精华内容 9,794
关键字:

无向图的邻接矩阵