般存储图的方式有两种：一是用邻接矩阵表示，二是用邻接链表。

所谓用邻接矩阵，是用一个二维数组存储，边使用矩阵来构建模型，这使得每一个顶点和其它顶点之间都有边的有无 的 表示的机会。若有边，则他们交点 为1 ，否则为0。当然，如果是一副边有权值的图，交点存储的是他们边的权值。

1、首先收一下无向图的存储：

无向图的边的矩阵一定是一个对称矩阵，因为无向图只关心边是否存在，而不关心方向，V0和V1有边，那么V1和V0也有边。

因为这里不研究有圈图，所以主对角线都是0，输入V0和V1边的关系后，就不必输入V1和V0的关系了。

图解如下：

[cpp] view plaincopy
  1. 实现代码如下：
[cpp] view plaincopy
  1. #include <iostream>
  2. using namespace std;
  3. #define MAX_VERTEX 4  //4个顶点的图
  4. typedef char DataType;
  5. typedef struct
  6. {
  7. DataType vertexArr[MAX_VERTEX];       //顶点元素数组
  8. int edgeArr[MAX_VERTEX][ MAX_VERTEX]; //边矩阵二维数组
  9. }ArrayGraph;
  10. void ArrayGraph_init(ArrayGraph *pGraph);
  11. void ArrayGraph_create(ArrayGraph *pGraph);
  12. void ArrayGraph_show(ArrayGraph *pGraph);
  13. int main()
  14. {
  15. ArrayGraph g;
  16. ArrayGraph_init(&g);       //初始化图
  17. ArrayGraph_create(&g);     //创建图
  18. ArrayGraph_show(&g);       //打印图
  19. return 0;
  20. }
  21. //初始化为一个无圈图 ，也就是边矩阵中，主对角线元素都是0
  22. void ArrayGraph_init(ArrayGraph *pGraph)
  23. {
  24. for (int i = 0; i < MAX_VERTEX; i++)
  25. pGraph->edgeArr[i][i] = 0;
  26. }
  27. //输入一个图
  28. void ArrayGraph_create(ArrayGraph *pGraph)
  29. {
  30. for (int i = 0; i < MAX_VERTEX; ++i)    //填充顶点数组，也就是输入顶点元素
  31. {
  32. printf("输入第%d个顶点值\n",i+1);
  33. scanf(" %c",&(pGraph->vertexArr[i]));
  34. }
  35. for (int j = 0; j <MAX_VERTEX; ++j)   //填充边关系
  36. {
  37. for (int i = j+1; i < MAX_VERTEX; ++i)
  38. {
  39. printf("若元素%c和%c有边，则输入1，否则输入0\t",pGraph->vertexArr[j],pGraph->vertexArr[i]);
  40. scanf("%d",&( pGraph->edgeArr[j][i]));
  41. pGraph->edgeArr[i][j] = pGraph->edgeArr[j][i];     //对称
  42. }
  43. }
  44. }
  45. void ArrayGraph_show(ArrayGraph *pGraph)
  46. {
  47. printf("\n\n顶点元素如下\n");
  48. for (int i = 0; i < MAX_VERTEX; ++i)
  49. {
  50. printf("%-5c", pGraph->vertexArr[i]);
  51. }
  52. printf("\n\n");
  53. puts("边矩阵如下\n\n");
  54. printf("%-2c",' ');
  55. for(int i=0;i<MAX_VERTEX;++i)
  56. printf("%-5c",pGraph->vertexArr[i]);
  57. putchar('\n');
  58. for (int j = 0; j <MAX_VERTEX; ++j)
  59. {
  60. printf("%-2c",pGraph->vertexArr[j]);
  61. for (int i = 0; i < MAX_VERTEX; ++i)
  62. {
  63. printf("%-5d",pGraph->edgeArr[i][j]);
  64. }
  65. putchar('\n');
  66. }
  67. printf("\n\n");
  68. }

2、有向图的邻接矩阵存储：

使用邻接矩阵呢存储时，有向图和无向图的区别在与 边和弧矩阵的差别。因为弧是有方向的，所以我们 以对角线为界，将矩阵划分为2个区域：

左下区域表示出弧标记区域，坐上区域代表入弧标记区域

如  若代表弧的矩阵为arcArr

arcArr[V2][V3] 为1，且在出弧标记区域，则说明 V3<------V2

arcArr[V3][V2] 为0，且在入弧标记区域，则说明 V2---\--->V3


代码实现如下：

[cpp] view plaincopy
  1. #include<stdio.h>
  2. #define  MAX_VERTEX  4
  3. typedef char DataType;                 //图中元素的目标数据类型
  4. typedef struct
  5. {
  6. DataType vertexArr[MAX_VERTEX];        //顶点元素数组
  7. int arcArr[MAX_VERTEX][MAX_VERTEX];   //弧矩阵二维数组
  8. }ArrayGraph;
  9. void ArrayGraph_init(ArrayGraph *pGraph);
  10. void ArrayGraph_create(ArrayGraph *pGraph);
  11. void ArrayGraph_show(ArrayGraph *pGraph);
  12. int main()
  13. {
  14. ArrayGraph g;
  15. ArrayGraph_init(&g);
  16. ArrayGraph_create(&g);
  17. ArrayGraph_show(&g);
  18. return 0;
  19. }
  20. //初始化为一个无圈图 ，也就是弧矩阵中，主对角线元素都是0
  21. void ArrayGraph_init(ArrayGraph *pGraph)
  22. {
  23. for (int i = 0; i < MAX_VERTEX; i++)
  24. pGraph->arcArr[i][i] = 0;
  25. }
  26. void ArrayGraph_create(ArrayGraph *pGraph)
  27. {
  28. for (int i = 0; i < MAX_VERTEX; ++i)  //填充顶点数组
  29. {
  30. printf("输入第%d个顶点值\n",i+1);
  31. scanf(" %c",&(pGraph->vertexArr[i]));
  32. }
  33. for (int j = 0; j <MAX_VERTEX; ++j)   //填充边关系
  34. {
  35. for (int i = j+1; i < MAX_VERTEX; ++i)
  36. {
  37. printf("若元素%c有指向%c的弧，则输入1，否则输入0\t",pGraph->vertexArr[i],pGraph->vertexArr[j]);
  38. scanf("%d",&( pGraph->arcArr[j][i]));
  39. printf("若元素%c有指向%c的弧，则输入1，否则输入0\t",pGraph->vertexArr[j],pGraph->vertexArr[i]);
  40. scanf("%d",&( pGraph->arcArr[i][j]));
  41. }
  42. }
  43. }
  44. void ArrayGraph_show(ArrayGraph *pGraph)
  45. {
  46. printf("\n\n顶点元素如下\n");
  47. for (int i = 0; i < MAX_VERTEX; ++i)
  48. {
  49. printf("%-5c", pGraph->vertexArr[i]);
  50. }
  51. printf("\n\n");
  52. puts("弧矩阵如下\n\n");
  53. printf("%-2c",' ');
  54. for(int i=0;i<MAX_VERTEX;++i)
  55. printf("%-5c",pGraph->vertexArr[i]);
  56. putchar('\n');
  57. for (int j = 0; j <MAX_VERTEX; ++j)
  58. {
  59. printf("%-2c",pGraph->vertexArr[j]);
  60. for (int i = 0; i < MAX_VERTEX; ++i)
  61. {
  62. printf("%-5d",pGraph->arcArr[i][j]);
  63. }
  64. putchar('\n');
  65. }
  66. putchar('\n');
  67. }

3、有权值无向图（无向网）的邻接矩阵存储：

无向网的边是有权值的，这个值可以是任何一个合法的值，什么样的值是合法的呢？这需要根据图的具体用途来定。所以，我们不能用简单的0,1来代表边。

如果2个顶点无关联，他们也不能用0表示，因为0也可能是一个合法的wieght值。可有类比一下：如何地球上2个地方之间不可互通，那么他们之间的车程费是不是无穷大呢？

所以，我们来要根据图权值类型定义一个相应类型的最大值，来代表2个顶点之间不关联。

同样用一个例子。

V0 V1之间的权值为12

V0 V2之间的权值为1

V0 V3之间的权值为5

V2 V3之间的权值为7

代码实现如下：

[cpp] view plaincopy
  1. #include<stdio.h>
  2. #define MAX_VERTEX 4
  3. #define INFINITY  65535
  4. typedef char DataType;     //存储的元素类型
  5. typedef int WeightType;    //权值的类型
  6. typedef struct
  7. {
  8. DataType vertexArr[MAX_VERTEX];             //存储顶点的数组
  9. WeightType edgeArr[MAX_VERTEX][MAX_VERTEX]; //存储边的二维数组
  10. }UArrayNet;     //数据结构类型：无向网
  11. void UArrayNet_init(UArrayNet*pGraph);
  12. void UArrayNet_create(UArrayNet*pGraph);
  13. void UArrayNet_show(UArrayNet *pGraph);
  14. int main()
  15. {
  16. UArrayNet net;
  17. UArrayNet_init(&net);
  18. UArrayNet_create(&net);
  19. UArrayNet_show(&net);
  20. return 0;
  21. }
  22. void UArrayNet_init(UArrayNet*pGraph)
  23. {
  24. for (int i = 0; i < MAX_VERTEX; ++i)
  25. {
  26. pGraph->edgeArr[i][i] = INFINITY;
  27. }
  28. }
  29. void UArrayNet_create(UArrayNet*pGraph)
  30. {
  31. for (int i = 0; i < MAX_VERTEX; ++i)  //填充顶点数组
  32. {
  33. printf("输入第%d个顶点值\n", i + 1);
  34. scanf(" %c", &(pGraph->vertexArr[i]));
  35. }
  36. for (int j = 0; j <MAX_VERTEX; ++j)   //填充边关系
  37. {
  38. for (int i = j + 1; i < MAX_VERTEX; ++i)
  39. {
  40. printf("若元素%c和%c有边，则输入权值，否则输入无效值%d\t", pGraph->vertexArr[j], pGraph->vertexArr[i], INFINITY);
  41. scanf("%d", &(pGraph->edgeArr[j][i]));
  42. pGraph->edgeArr[i][j] = pGraph->edgeArr[j][i];     //对称
  43. }
  44. }
  45. }
  46. void UArrayNet_show(UArrayNet *pGraph)
  47. {
  48. printf("\n\n顶点元素如下\n");
  49. for (int i = 0; i < MAX_VERTEX; ++i)
  50. {
  51. printf("%-5c", pGraph->vertexArr[i]);
  52. }
  53. printf("\n\n");
  54. puts("边矩阵如下");
  55. printf("%-2c", ' ');
  56. for (int i = 0; i<MAX_VERTEX; ++i)
  57. printf("%-5c", pGraph->vertexArr[i]);
  58. putchar('\n');
  59. for (int j = 0; j <MAX_VERTEX; ++j)
  60. {
  61. printf("%-2c", pGraph->vertexArr[j]);
  62. for (int i = 0; i < MAX_VERTEX; ++i)
  63. {
  64. if(pGraph->edgeArr[i][j]==INFINITY)
  65. {
  66. printf("%-5c", '#');
  67. }
  68. else
  69. printf("%-5d", pGraph->edgeArr[i][j]);
  70. }
  71. putchar('\n');
  72. }
  73. }

4、有向网邻接矩阵存储

有向网的实现与无向网思路一致，就不重复累赘了，直接上代码吧。

[cpp] view plaincopy
  1. #include<stdio.h>
  2. #define MAX_VERTEX 4
  3. #define INFINITY  65535
  4. typedef char DataType;     //存储的元素类型
  5. typedef int WeightType;    //权值的类型
  6. typedef struct
  7. {
  8. DataType vertexArr[MAX_VERTEX];             //存储顶点的数组
  9. WeightType arcArr[MAX_VERTEX][MAX_VERTEX]; //存储边的二维数组
  10. }UArrayNet;     //数据结构类型：无向网
  11. void UArrayNet_init(UArrayNet*pGraph);
  12. void UArrayNet_create(UArrayNet*pGraph);
  13. void UArrayNet_show(UArrayNet *pGraph);
  14. int main()
  15. {
  16. UArrayNet net;
  17. UArrayNet_init(&net);
  18. UArrayNet_create(&net);
  19. UArrayNet_show(&net);
  20. return 0;
  21. }
  22. void UArrayNet_init(UArrayNet*pGraph)
  23. {
  24. for (int i = 0; i < MAX_VERTEX; ++i)
  25. {
  26. pGraph->arcArr[i][i] = INFINITY;
  27. }
  28. }
  29. void UArrayNet_create(UArrayNet*pGraph)
  30. {
  31. for (int i = 0; i < MAX_VERTEX; ++i)  //填充顶点数组
  32. {
  33. printf("输入第%d个顶点值\n", i + 1);
  34. scanf(" %c", &(pGraph->vertexArr[i]));
  35. }
  36. for (int j = 0; j <MAX_VERTEX; ++j)   //填充边关系
  37. {
  38. for (int i = j + 1; i < MAX_VERTEX; ++i)
  39. {
  40. printf("若元素%c有指向%c有边，则输入权值，否则输入无效值%d\t", pGraph->vertexArr[j], pGraph->vertexArr[i], INFINITY);
  41. scanf("%d",&( pGraph->arcArr[j][i]));
  42. printf("若元素%c有指向%c有边，则输入权值，否则输入无效值%d\t", pGraph->vertexArr[i], pGraph->vertexArr[j], INFINITY);
  43. scanf("%d",&( pGraph->arcArr[i][j]));
  44. }
  45. }
  46. }
  47. void UArrayNet_show(UArrayNet *pGraph)
  48. {
  49. printf("\n\n顶点元素如下\n");
  50. for (int i = 0; i < MAX_VERTEX; ++i)
  51. {
  52. printf("%-5c", pGraph->vertexArr[i]);
  53. }
  54. printf("\n\n");
  55. puts("边矩阵如下");
  56. printf("%-2c", ' ');
  57. for (int i = 0; i<MAX_VERTEX; ++i)
  58. printf("%-5c", pGraph->vertexArr[i]);
  59. putchar('\n');
  60. for (int j = 0; j <MAX_VERTEX; ++j)
  61. {
  62. printf("%-2c", pGraph->vertexArr[j]);
  63. for (int i = 0; i < MAX_VERTEX; ++i)
  64. {
  65. if(pGraph->arcArr[i][j]==INFINITY)
  66. {
  67. printf("%-5c", '#');
  68. }
  69. else
  70. printf("%-5d", pGraph->arcArr[i][j]);
  71. }
  72. putchar('\n');
  73. }
  1. }
http://blog.csdn.net/smarter_shability/article/details/69664755

有向图和无向图用邻接矩阵储存相关推荐

  1. 有向图，无向图的邻接矩阵和邻接表模板

    图 图的定义 有向图 概念 模板 邻接矩阵 邻接表 无向图 概念 模板 邻接矩阵 邻接表 简单图 完全图 图的定义 图 GGG 由顶点集 VVV 和边集 EEE 组成,记为 G=(V,E)G=(V,E ...

  2. 邻接矩阵，构造有向图、无向图、有向网、无向网,深度优先、广度优先遍历（C++图）

    #include <iostream> using namespace std; #define INFINITY INT_MAX #define MAX_VERTEX_NUM 20//最 ...

  3. 采用邻接表存储有向图，设计算法判断任意两个顶点间是否存在路径。设计算法，将一个无向图的邻接矩阵转换为邻接表。

    采用邻接表存储有向图,设计算法判断任意两个顶点间是否存在路径.设计算法,将一个无向图的邻接矩阵转换为邻接表. 采用邻接表存储有向图,设计算法判断任意两个顶点间是否存在路径. 设计算法,将一个无向图的邻 ...

  4. 图论 Make Unique：有向图和无向图的一些算法

    计算机科学入门资料之一的<算法与数据结构-C语言版>,覆盖了基础算法的几乎所有分支,其中的一个典型分支为图理论. 一个简介:图论基础-图数据结构基础 一个简洁的博客:图论基础,简列一本书 ...

  5. 学习有向图和无向图的强连通分量（基本概念+割点+点双联通分量+桥+边双连通分量+全套模板【Tarjan】）

    最近总是考到Tarjan,让我措手不及 基本概念 割点以及点双连通分量 Tarjan法求割点 推导过程 代码实现 Tarjan法求点双连通分量 推导过程 代码实现 有向图的Tarjan缩点 桥与边双连 ...

  6. 图（有向图、无向图）

    一.图的概念 1 ．图的定义 图 1.3-1所示的 ⑴, ⑵, ⑶均为图 (Graph),它有若干个不同的点 v 1, v 2, -, v n,在其中一些点之间用直线或曲线连接.图中的这些点被称为顶点 ...

  7. 有向图和无向图的相关概念

    图的定义: 图在数据结构中是中一对多的关系,一般分为无向图与无向图 常用 邻接矩阵 或者 邻接链表 来表示图中结点的关系 ⑴图是由顶点集V和顶点间的关系集合E(边的集合)组成的一种数据结构 ⑵用二元组 ...

  8. 数据结构—无向图创建邻接矩阵、深度优先遍历和广度优先遍历（C语言版）

    无向图创建邻接矩阵.深度优先遍历和广度优先遍历 一.概念解析: (1)无向图: (2)邻接矩阵: 二.创建邻接矩阵: 三.深度遍历.广度遍历 (1)深度遍历概念: (2)广度遍历概念: 四.实例展示 ...

  9. 数学建模——有向图和无向图

    有向图和无向图 本讲将简要介绍图论中的基本概念,并主要讲解图论中的最短路径问题.根据图的不同,我们将学习两种不同的算法:迪杰斯特拉Diijkstta算法和Bellman-Ford(贝尔曼-福特)算法. ...

  10. 无向图的邻接矩阵存储，4个顶点、4条边

    // //  main.cpp //  Graph_wuxiang // //  Created by duanqibo on 2019/6/29. //  Copyright © 2019年 dua ...

最新文章

  1. 数据库-多表查询-笛卡尔积
  2. python 学习DAY03
  3. uni-app阻止事件冒泡
  4. Android IPC机制（二）用Messenger进行进程间通信
  5. python编程（pyautogui库）
  6. hive使用适用场景_数据分析之hive学习（四）：面试题——场景输出（row_number）...
  7. Linux下如何用GDB调试c++程序 [版本2]
  8. c#的IList,IEnumerable和IEnumerator
  9. 判断一个单链表是否有环及环的链接点
  10. 世界记忆大师的记忆力训练方法
  11. 计算机更新有用吗,驱动有必要升级吗_n卡驱动有必要更新吗
  12. 基于微信驾校考试小程序系统设计与实现 开题报告
  13. debian下配置防火墙iptables
  14. android bootload漏洞,一加6手机的Bootloader漏洞可让攻击者控制设备
  15. 爬虫实战教程：采集微信公众号文章
  16. 如何在Windows 10中使用“Netsh Winsock Reset”？
  17. 使用PS去水印的方法
  18. iOS短视频源码音频采集过程中的音效实现 1
  19. DevOps自动化之Jenkins
  20. C/C++: c语言中的多行注释和单行注释

热门文章

  1. autoit3 自动安装QQ音乐【版本QQMusicV7.96.2062.0525】
  2. 做开发十年，我总结出了这些开发经验
  3. 开放平台API安全设计方案
  4. 《领导力与沟通艺术》
  5. 交付团队管理_如何建立有效的软件交付团队4个关键组成部分
  6. javascript nonono
  7. cousera视频无法播放
  8. 浅谈智能搜索和对话式OS
  9. Element UI 之 Tabs 栏下拉菜单的实现
  10. Linux基金会：开源技术不受制于《美国出口管制条例》EAR 限制，可自由使用