精华内容
下载资源
问答
  • 数据结构邻接矩阵存储
    2022-04-01 16:57:00

    1、 图的存储方法:邻接矩阵存储(无向图)

    测试数据:
    4 5
    A B C D
    0 1
    0 2
    0 3
    1 2
    1 3

    邻接矩阵:

    顶点ABCD
    A0111
    B1011
    C1100
    D1100

    #include<iostream>
    #include<malloc.h>
    using namespace std;     //vertex:顶点    arc:弧    adjacent:邻近的 
    #define MaxVertexNum 100  //最大顶点数
    typedef char VertexType;  //顶点的数据类型
    typedef int EdgeType;   //边的数据类型
    typedef struct{
    	VertexType Vex[MaxVertexNum];  //定点表 
    	EdgeType  Edge[MaxVertexNum][MaxVertexNum];  //邻接矩阵,边表 
    	int vernum,arcnum; //图的当前顶点数和弧数 
    }MGraph; //适合存储稠密图 
    
    //邻接矩阵法创建一个图 
    void CreateGraph(MGraph *G)
    {
    	int i,j,k,w;
    	printf("请输入图的顶点数和边数:");
    	cin>>G->vernum>>G->arcnum;
    	printf("请输入图的各个顶点的信息(A,B…):");
    	for(i=0;i<G->vernum;i++)
    		cin>>G->Vex[i];//"%c"中%c后面要有空格 
    	for(i=0;i<G->vernum;i++)
    	{
    		for(j=0;j<G->vernum;j++)
    			G->Edge[i][j]=0;		
    	} 
    	printf("请输入各条边的信息(例:1 2表示在A顶点和B顶点之间有一条边):\n");
    	for(k=0;k<G->arcnum;k++)
    	{//此为创建有向图的邻接矩阵 
    		int Iindex,Jindex; 
    		cin>>Iindex>>Jindex;
    		G->Edge[Iindex][Jindex]=1;
    		//如果加上G->Edge[j][i]=1;则建立的是无向图的邻接矩阵 
    		G->Edge[Jindex][Iindex]=1;
    	}		
    } 
    
    //打印邻接矩阵
    void DisplayMGraph(MGraph G)
    {
    	int i,j;
    	printf("	");
    	for(i=0;i<G.vernum;i++)
    	printf("%c ",G.Vex[i]);
    	for(i=0;i<G.vernum;i++)
    	{
    		printf("\n%c\t",G.Vex[i]);
    		for(j=0;j<G.vernum;j++)
    			printf("%d ",G.Edge[i][j]); 
    	}	
    } 
    
    //求图G中顶点x的第一个邻接点
    int FirstNeighbor(MGraph G,char x)
    {
    	int i,j;
    	for(i=0;i<G.vernum;i++)//找到x在顶点表中的位置 
    	{
    		if(x==G.Vex[i])
    			break; 
    	}
    	for(j=0;j<G.vernum;j++)//在邻接矩阵中找到x所在行的值为1的元素。 
    	{
    		if(G.Edge[i][j]==1)
    			break;
    	}
    	if(j<G.vernum)
    		return j;
    	else
    		return -1; 
    } 
    
    //求图G中顶点y是顶点x的一个邻接点,返回除y外顶点x的下一个邻接点的顶点号
    //若y是x的最后一个邻接点,则返回-1
    int NextNeighbor(MGraph G, char x,char y)
    {
    	int i,j,k;
    	for(i=0;i<G.vernum;i++)
    	{
    		if(x==G.Vex[i])
    			break; 
    	}
    	for(j=0;j<G.vernum;j++)//在邻接矩阵中找到x所在行的值为1的元素。 
    	{
    		if(G.Vex[j]==y&&G.Edge[i][j]==1)
    			break;
    	}
    	for(k=j+1;k<G.vernum;k++)
    		if(G.Edge[i][k]==1)
    			break;
    	if(k<=G.vernum)
    		return k;
    	else
    		return -1; 
    } 
    
    int main()
    {
    	MGraph G;
    	CreateGraph(&G);
    	printf("图的邻接矩阵如下:\n");
    	DisplayMGraph(G);
    	int index1=FirstNeighbor(G,'A');
    	if(index1!=-1)
    		printf("\n顶点A的第一个邻接点是%c\n",G.Vex[index1]);
    	else
    		printf("顶点A没有邻接点!\n");
    	int index2=NextNeighbor(G,'A','C');
    	if(index2!=-1)
    		printf("\n顶点A的第一个邻接点是%c\n",G.Vex[index2]);
    	else
    		printf("顶点C是顶点A的最后一个邻接点!\n");
    	return 0;
    } 
    

    运行截图

    在这里插入图片描述

    更多相关内容
  • 主要为大家详细介绍了C语言实现邻接矩阵存储操作,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 领会的两种主要存储结构基本运算算法和两种遍历算法设计内容:编写一个程序,设计带权邻接矩阵与邻接表的创建和输出运算,并在此基础上设计一个主程序完成如下功能:(1)建立如所示的有向G的邻接矩阵...
  • 仅限学习使用 个人资料整理 数学与计算机学院 课程设计说明书 数据结构与算法课程设计名 称: 课程 : 6014389 码程 代 课 目: 无向邻接矩阵存储结构题 4班 级软件年级专业班: 2018// 名: 吴超学 生 姓 号: ...
  • 本文实例讲述了C++实现邻接矩阵存储和广度、深度优先遍历的方法。分享给大家供大家参考。具体如下: 示例:建立如所示的无向 由上知,该有5个顶点,分别为a,b,c,d,e,有6条边. 示例输入(按照这个格式...
  • 主要介绍了Java编程实现邻接矩阵表示稠密代码示例,具有一定参考价值,需要的朋友可以了解下。
  • 数据结构图邻接矩阵,邻接表存储表示,的深度优先搜索遍历,广度优先搜索遍历 数据结构图邻接矩阵,邻接表存储表示,的深度优先搜索遍历,广度优先搜索遍历.rar
  • 52-邻接矩阵存储结构及算法

    千次阅读 2018-07-17 16:37:35
    2. 邻接矩阵存储方法   邻接矩阵是表示顶点之间相邻关系的矩阵。设G = (V , E)是具有n(n &amp;amp;amp;amp;amp;amp;amp;amp;gt; 0)个顶点的,顶点的编号依次为0 ~ n-1。G的邻接矩阵A是n阶方阵,其定义...

    1. 图的存储结构

      通常我们要根据图的逻辑结构来设计图的存储结构来 存储每个顶点的信息,存储每条边的信息。图的存储结构有以下两种:

      1. 邻接矩阵存储方法

      2.邻接表存储方法

    2. 邻接矩阵存储方法

      邻接矩阵是表示顶点之间相邻关系的矩阵。设G = (V , E)是具有n(n > 0)个顶点的图,顶点的编号依次为0 ~ n-1。G的邻接矩阵A是n阶方阵,其定义如下所示:

    这里写图片描述
    图1-无向图

      我们知道邻接矩阵A是表示无向图中顶点之间相邻关系,比如在无向图中(0,1)顶点之间有一条边,互为邻接点关系,那么对应的在邻接矩阵A[0][1]中对应的元素就为1 。再比如无向图中(0,0)是顶点0到顶点0自己,没有边,不是邻接点关系,那么在邻接矩阵A[0][0]中对应的元素就为0。

      因此我们可以总结为:若(i,j)∈ E( G ),说明顶点之间互为邻接点关系,那么A[i][j] = 1;其他情况A[i][j] = 0 。



    这里写图片描述
    图2-有向图

      对于有向图来说,邻接矩阵A是表示有向图中顶点之间的相邻关系,如果有相邻关系则邻接矩阵A中对应的元素值就为1。比如在有向图中<0,1>顶点之间有一条边,顶点0和顶点1互为邻接点关系,那么对于的在邻接矩阵A[0][1]中的元素值为1 。又比如有向图中不存在顶点1到顶点0这样的一条边,那么在邻接矩阵A[1][0]中对应的元素值为0。

      因此我们可以总结为:若< i,j > ∈ E( G ),说明顶点之间互为邻接点关系,那么A[i][j] = 1;其他情况A[i][j] = 0 。



    这里写图片描述
    图3-带权无向图

      对于带权无向图来说,(1,2)顶点之间互为邻接点关系,且顶点1到顶点2的边的权为8,那么在邻接矩阵A[1][2]对应的元素值为8。而顶点1到顶点3不是互为邻接点关系,没有边,因此顶点1到顶点3的权无穷大,那么在邻接矩阵A[1][3]对应的元素值用“∞”符号表示,也就是无穷大的意思。顶点1到顶点1非邻接点关系,在邻接矩阵A[1][1]中元素值为0表示,同时我们还能看到带权无向图的邻接矩阵A也是一个对称关系。

    因此我们可以总结为:
       wij w i j 表示顶点i到顶点j的边的权

      如果i ≠ j,且(i,j)∈ E(G),说明顶点i和顶点j互为邻接点关系,那么A[i][j] = wij w i j

      如果i = j,那么A[i][j] = 0

      其他情况,那么A[i][j]用“∞”符号表示

    这里写图片描述
    图4-带权有向图

      经过有向图,无向图,无向带权图的学习,相信你对这几种图结构的特点非常清楚了,对于带权有向图同理,我们就不再详细介绍,直接总结为:
       wij w i j 表示顶点i到顶点j的边的权

      如果i ≠ j,且< i,j > ∈ E(G),说明顶点i和顶点j互为邻接点关系,那么A[i][j] = wij w i j

      如果i = j,那么A[i][j] = 0

      其他情况,那么A[i][j]用“∞”符号表示

    3. 邻接矩阵的特点

      1.图的邻接矩阵表示是唯一的。

      2.通过学习邻接矩阵的存储方法我们可知,对于无向图的邻接矩阵一定是一个对称矩阵,既然是对称矩阵,那么我们就可以考虑压缩存储。

      而不少邻接矩阵是一个稀疏矩阵,当图的顶点较多时,可以采用三元组的方式存储。比如对于有向图的邻接矩阵来说,并不是对称的,更接近于稀疏矩阵,因此更适合采用三元组的方式存储。

      3. 另外,从这样的邻接矩阵中我们还可以很方便的得到顶点的度。

      对于无向图来说,邻接矩阵的第i行(或第i列)非零元素(或非∞元素)的个数正好是第i个顶点的度。比如从图1(无向图)的邻接矩阵中的第0行的非零元素(或非∞元素)个数为2,那么我们就可以知道无向图中第0个顶点的度就为2(不理解的小伙伴可以回到图1看一下),即从顶点0出发的边有2条,而邻接矩阵中的第i列中非零元素个数也是2,则说明到达顶点0的边也有2条。

      对于有向图来说,邻接矩阵的第i行(或第i列)非零元素(或非∞元素)的个数正好是第i个顶点的出度(或入度)。比如从图2(有向图)的邻接矩阵中的第0行的非零元素(或非∞元素)个数为1,说明第0个顶点的出度为1。且图2(有向图)的邻接矩阵中的第0列中非零元素(或非∞元素)个数为1,说明第0个顶点的入度也是为1。

      4. 采用邻接矩阵存储图,很容易确定图中任意两个顶点之间是否有边相连。要确定图中有多少条边,则必须按行,按列对每个元素进行检测,时间消耗较大。

    4. 邻接矩阵的数据类型定义

    这里写图片描述
    图5

      对于上图中这样的存储结构,我们要思考的是怎么用程序设计语言去定义邻接矩阵的数据类型,而前面我们说过:需要存储每个顶点的信息,存储每条边的信息;在实际应用中顶点可能存在某些意义,因此必须定义一个顶点类型,用于存放顶点的信息,定义如下:

    #define MAXV <最大顶点个数>
    
    #define LIMITLESS 9999   //9999表示∞
    
    //顶点类型
    typedef struct
    {
        int no;             //顶点编号
        InfoType info;      //顶点其他信息
    } VertexType; 
    
    //图的定义:邻接矩阵
    typedef struct 
    {
        int n,e;                    //顶点数,边数
        int edges[MAXV][MAXV];      //邻接矩阵
        VertexType vexs[MAXV];      //存放顶点信息
    } MGraph;
    展开全文
  • 邻接矩阵存储结构

    千次阅读 2020-07-05 22:21:03
    邻接矩阵存储结构 一、知识框架 二、存储方式(这里只讨论邻接矩阵存储方式) 在邻接矩阵存储结构中,顶点信息使用一维数组存储,边信息的邻接矩阵使用二维数组存储。 无向和其对应的邻接矩阵 有向 ...

    图的邻接矩阵存储结构

    一、知识框架

    在这里插入图片描述

    二、存储方式(这里只讨论邻接矩阵存储方式)

    在图的邻接矩阵存储结构中,顶点信息使用一维数组存储,边信息的邻接矩阵使用二维数组存储。

    • 无向图和其对应的邻接矩阵
    • 在这里插入图片描述
      在这里插入图片描述
    • 有向图
      在这里插入图片描述

    三、代码实现

    1.头文件AdjMGraph.h
    针对的是下面这个有向图
    在这里插入图片描述

    #pragma once
    //图的邻接矩阵存储结构
    #include "SeqList.h"
    typedef struct {
    	SeqList Vertices;   //存放顶点的顺序表
    	int edge[MaxVertices][MaxVertices];//存放边的邻接矩阵
    	int numOfEdges;            //边的条数
    }AdjMGraph;        //图的结构体定义
    //初始化
    void Initiate(AdjMGraph *G, int n)
    {
    	int i, j;
    	for(i=0;i<n;i++)
    		for (j = 0; j < n; j++) {
    			if (i == j) {
    				G->edge[i][j] = 0;
    			}
    			else {
    				G->edge[i][j] = MaxWeight;    //MaxWeight表示无穷大
    			}
    		}
    	G->numOfEdges = 0;      //边的条数置零
    	ListInitiate(&G->Vertices);   //顺序表初始化
    }
    //插入顶点
    void InsertVertex(AdjMGraph *G, DataType vertex) {
    	//在途中插入顶点Vertex
    	ListInsert(&G->Vertices, G->Vertices.size, vertex);//在顺序表尾部插入
    }
    /*
    插入边
    在有向图中插入一条有向边。对于增加无向边的操作,可通过增加两条有向边完成。
    */
    void InsertEdge(AdjMGraph *G, int v1, int v2, int weight) {
    	//在图中插入边<v1,v2>,边<v1,v2>的权为weight
    	if (v1 < 0 || v1 >= G->Vertices.size || v2 < 0 || v2 >= G->Vertices.size) {
    		printf("参数v1或v2越界出错!\n");
    		return;
    	}
    	G->edge[v1][v2] = weight;
    	G->numOfEdges++;
    }
    /*
    删除边
    在图中删除一条有向边。对于删除无向边的操作,可通过取消两条有向边完成
    */
    void DeleteEdge(AdjMGraph *G, int v1, int v2) {
    	//在图中删除边<v1,v2>
    	if (v1 < 0 || v1 >= G->Vertices.size || v2 < 0 || v2 >= G->Vertices.size || v1 == v2) {
    		printf("参数v1或者v2越界出错!\n");
    		return;
    	}
    	if (G->edge[v1][v2] == MaxWeight || v1 == v2) {
    		printf("该边不存在!\n");
    		return;
    	}
    	G->edge[v1][v2] = MaxWeight;
    	G->numOfEdges--;
    }
    /*
    取第一个邻接顶点
    对于邻接矩阵来说,顶点v的第一个邻接顶点,就是邻接矩阵的顶点v行中
    从第一个矩阵元素开始的非0且非无穷大的顶点
    */
    int GetFirstVex(AdjMGraph G, int v)
    //在图G中寻找序号为v的顶点的第一个邻接顶点
    //如果这样的邻接顶点存在,则返回该邻接顶点的序号,否则返回-1
    {
    	int col;
    	if (v < 0 || v >= G.Vertices.size) {
    		printf("参数v1越界出错");
    		return -1;
    	}
    	else {
    		for (col = 0; col < G.Vertices.size; col++) {
    			if (G.edge[v][col] > 0 && G.edge[v][col] < MaxWeight)
    				return col;
    		}
    		return -1;
    	}
    }
    /*
    取下一个邻接顶点
    对于邻接矩阵存储结构来说,顶点v1的邻接顶点v2的下一个邻接顶点,就是邻接矩阵的顶点
    v行中从第v2+1个矩阵元素开始的非0且非无穷大的顶点
    */
    int GetNextVex(AdjMGraph G, int v1, int v2) {
    	//在图中寻找v1的顶点的邻接顶点v2的下一个邻接顶点
    	//如果这样的邻接顶点存在,则返回该邻接顶点的序号,否则返回-1
    	//v1和v2都是相应顶点的序号
    	int col;
    	if (v1 < 0 || v1 >= G.Vertices.size || v2 < 0 || v2 >= G.Vertices.size) {
    		printf("参数v1或v2越界出错!\n");
    		return -1;
    	}
    	for (col = v2 + 1; col < G.Vertices.size; col++) {
    		if (G.edge[v1][col] > 0 && G.edge[v1][col] < MaxWeight)
    			return col;
    	}
    	return -1;
    }
    
    

    2.SeqList.h

    #pragma once
    typedef struct {
    	DataType list[MaxSize];
    	int size;
    }SeqList;
    //初始化
    void ListInitiate(SeqList *L) {
    	L->size = 0;
    }
    //求当前数据元素个数
    int ListLength(SeqList L) {
    	return L.size;
    }
    //插入数据元素
    int ListInsert(SeqList *L, int i, DataType x) {
    	//在顺序表的第i个位置(0<=i<=size)个位置前插入数据元素值x
    	//插入成功返回1,插入失败返回0
    	int j;
    	if (L->size >= MaxSize) {
    		printf("顺序表已满无法插入!");
    		return 0;
    	}
    	else if (i<0 || i>L->size) {
    		printf("参数i不合法!\n");
    		return 0;
    	}
    	else {
    		//从后向前依次后移数据,为插入做准备
    		for (j = L->size; j > i; j--) {
    			L->list[j] = L->list[j - 1];
    		}
    		L->list[i] = x;
    		L->size++;
    		return 1;
    	}
    }
    //删除数据元素
    int ListDelete(SeqList *L, int i, DataType *x) {
    	//删除顺序表L中第i(0<=i<=size-1)个位置处的数据元素并保存到x中
    	//删除成功返回1,删除失败返回0
    	int j;
    	if (L->size <= 0) {
    		printf("顺序表已空无法删除!\n");
    		return 0;
    	}
    	else if (i<0 || i>L->size - 1) {
    		printf("参数i不合法");
    		return 0;
    	}
    	else {
    		*x = L->list[i];//保存删除的元素到x中
    		//从前向后依次前移
    		for (j = i + 1; j <= L->size - 1; j++) {
    			L->list[j - 1] = L->list[j];
    		}
    		L->size--;
    		return 1;
    	}
    }
    //取数据元素
    int ListGet(SeqList L, int i, DataType *x) {
    	//取顺序表的第i个数据元素存于x中,成功返回1,失败返回0
    	if (i<0 || i>L.size - 1) {
    		printf("参数i不合法!");
    		return 0;
    	}
    	else {
    		*x = L.list[i];
    		return 1;
    	}
    }
    

    3.AdjMGraphCreate.h

    #pragma once
    #include "AdjMGraph.h"
    typedef struct {
    	int Row;   //行下标
    	int col;   //列下标
    	int weight;  //权值
    }RowColWeight;   //边信息结构体定义
    void CreateGraph(AdjMGraph *G, char V[], int n, RowColWeight E[], int e) {
    	//在图G中插入n个顶点信息V和e条边信息E
    	int i, k;
    	Initiate(G, n);    //顶点顺序表初始化
    	for (i = 0; i < n; i++)
    		InsertVertex(G, V[i]);//插入顶点
    	for (k = 0; k < e; k++)
    		InsertEdge(G, E[k].Row, E[k].col, E[k].weight);//插入边
    }
    

    4.源文件:test.cpp

    #pragma once
    #include<stdio.h>
    #include<stdlib.h>
    typedef char DataType;
    #define MaxSize 10
    #define MaxVertices 10
    #define MaxWeight 10000
    #include "SeqList.h"
    #include "AdjMGraph.h"
    #include "AdjMGraphCreate.h"
    int main() {
    	AdjMGraph g1;
    	DataType a[] = { 'A','B','C','D','E' };
    	RowColWeight rcw[] = { {0,1,10},{0,4,20},{1,3,30},{2,1,40},{3,2,50} };
    	int n = 5, e = 5;
    	int i, j;
    	CreateGraph(&g1, a, n, rcw, e);
    	//DeleteEdge(&g1, 0, 4);//删除边<0,4>
    	printf("顶点集合为:");
    	for (i = 0; i < g1.Vertices.size; i++) {
    		printf("%c  ", g1.Vertices.list[i]);
    	}
    	printf("\n");
    	printf("权值集合为:\n");
    	for (i = 0; i < g1.Vertices.size; i++) {
    		for (j = 0; j < g1.Vertices.size; j++) {
    			printf("%5d  ", g1.edge[i][j]);
    		}
    		printf("\n");
    	}
    	system("pause");
    }
    

    5.运行结果
    在这里插入图片描述

    展开全文
  • 问题描述使用邻接矩阵存储所示无向**** 解题思路创建一个邻接矩阵程序实现#include #include #define MAXVEX 10/* Status是函数的类型,其值是函数结果状态代码,如OK等 */typedef int Status;/* 顶点类型应由...

    问题描述

    使用邻接矩阵存储下图所示无向图

    **

    d56c08578f4b6ad9c71810b0ab70a1aa.png**

    解题思路

    创建一个邻接矩阵

    程序实现

    #include

    #include

    #define MAXVEX 10

    /* Status是函数的类型,其值是函数结果状态代码,如OK等 */

    typedef int Status;

    /* 顶点类型应由用户定义 */

    typedef char VertexType;

    /* 边上的权值类型应由用户定义 */

    typedef int EdgeType;

    typedef struct {

    VertexType vex[MAXVEX];

    EdgeType arc[MAXVEX][MAXVEX];

    int numNodes, numEdges;

    } MyGraph, *GraphPlus;

    void CreateMyGraph(GraphPlus *plus);

    int main(void) {

    int i, j;

    GraphPlus plus;

    CreateMyGraph(&plus);

    for (i = 0; i < plus->numNodes; i++) {

    for (j = 0; j < plus->numNodes; j++) {

    printf("%d\t", plus->arc[i][j]);

    }

    printf("\n");

    }

    }

    void CreateMyGraph(GraphPlus *plus) {

    int i, j, k, w;

    printf("请输入顶点数和边数:\n");

    scanf("%d,%d", &i, &j);

    *plus = (GraphPlus)malloc(sizeof(MyGraph));

    getchar();

    (*plus)->numNodes = i;

    (*plus)->numEdges = j;

    // 读入顶点数

    for (i = 0; i < (*plus)->numNodes; i++) {

    scanf("%c", &(*plus)->vex[i]);

    }

    // 初始化边数组

    for (i = 0; i < (*plus)->numNodes; i++) {

    for (j = 0; j < (*plus)->numNodes; j++) {

    (*plus)->arc[i][j]=0;

    }

    }

    // 读入numEdges条边,建立邻接矩阵

    for(k = 0; k < (*plus)->numEdges; k++) {

    printf("输入边(vi,vj)上的下标i,下标j:\n");

    scanf("%d,%d", &i, &j);

    (*plus)->arc[i][j] = 1;

    // 因为是无向图,矩阵对称

    (*plus)->arc[j][i] = (*plus)->arc[i][j];

    }

    }

    运行结果

    d201b1a5757a5331d409e6bfcee56944.png

    展开全文
  • 邻接矩阵法 无向 #include<stdio.h> #define MaxVertenNum 6 //顶点数目的最大值 typedef char VertexType; //顶点的数据类型 typedef int EdgeType; //存放顶点信息 typedef struct { VertexType Vex...
  • 浙江大学城市学院实验报告课程名称 数据结构基础实验项目名称 实验十二 的基本操作—邻接矩阵存储结构学生姓名 专业班级 学号实验成绩 指导老师(签名 ) 日期实验目的和要求1、掌握的存储结构:邻接矩阵。...
  • 无向邻接矩阵存储及输出无向邻接矩阵存储及输出
  • 邻接矩阵储存无向

    2018-09-01 17:06:04
    采用邻接矩阵实现无向存储,并输入输出邻接矩阵。实现的广度优先遍历和深度优先遍历。
  • 邻接矩阵建立存储结构,并进行深度优先搜索、广度优先搜索。
  • 的基本操作 存储结构有邻接矩阵与邻接表 这里采用邻接矩阵存储 有有向、无向,还有带权值和不带权值的 代码都差不多,就几个地方改一下就就行 本文以带权有向为例 其他修改也有注明
  • 1、建立有向邻接矩阵存储并完成以下工作: (1)、输出该邻接矩阵; (2)、求出第i个顶点的出度并输出; (3)、求出第i个顶点的入度并输出; 代码内容 #include<iostream> #define Max 327 //表示极大值,代表...
  • 使用邻接矩阵存储图

    2021-04-10 15:59:46
    其实相比于其它数据结构较复杂,但也是十分易懂的,对于使用邻接矩阵存储来说,我们所需要知道的数据有 的定点数、边数、用一个二维数组存储的边与边的联系及其权值,未连接的边我们要使用无穷表示,节点...
  • c/c++实现的Dijkstra算法
  • 本代码的邻接矩阵的顶点设为v0、v1、v2、v3、v4、v5,从v0开始。 代码实现 #include<stdio.h> #include<malloc.h> typedef int InfoType; #define MAXV 100 //最大顶点个数 #define INF 32767 //...
  • 有向图邻接矩阵c++运算操作 基本操作 邻接矩阵 c++实现
  • 一、邻接矩阵 #include <iostream>...//邻接矩阵存储结构 typedef struct{ char Vex[MaxVertexNum]; //顶点表 int Edge[MaxVertexNum][MaxVertexNum]; //边表 int vexnum,arcnum; //当前顶点数
  • 定义采用邻接矩阵存储图结构封装DFS、BFS算法
  • 程序设计任务: 设计一个程序,实现以邻接表或者邻接矩阵存储结构,实现连通无向的深度优先和广度优先遍历。基本要求:以邻接表或者邻接矩阵存储结构,实现连通无向的深度优先和广度优先遍历。以用户指定的...
  • 源程序及注释 #include<iostream>...//邻接矩阵(数组)存储表示 #defineMaxINt32767 //表示极大值,即无穷 #defineMVNum100 //最大顶点数 typedefintArcType; //假设边的权值类型为整...
  • 邻接矩阵存储无向

    2021-09-14 11:53:41
    邻接矩阵的优势: 可以快速判断两个顶点之间是否有边; 方便计算各顶点的度,无向中:顶点i的度 = 邻接矩阵第i...有向中:顶点的出度 = 邻接矩阵第i行中的元素和,顶点的入度 = 邻接矩阵第i列中的元素和。 ...
  • 邻接矩阵代码实现 今天看了下的一些基本概念,由于有图形,因此关于的知识点理解起来还算轻松,苦于就是各种各样的基本操作的代码实现; 由于自己编程能力停留在会点基本的C++,因此书上或者网上找到的代码...
  • 对于无权邻接矩阵可以表示为: 对于有权: 举例: 右边的矩阵即为无向中的邻接矩阵表示。矩阵中第i行j列个元素Gij,若等于1则表示从i到j有边,若等于0则表示无边。 特点: 无向图邻接矩阵关于主对角线...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,884
精华内容 9,153
关键字:

图的邻接矩阵存储结构

友情链接: SqStack.zip