图的存储结构（1）：数组表示法

最新推荐文章于 2023-06-01 22:20:49 发布
最新推荐文章于 2023-06-01 22:20:49 发布
阅读量1.1k 收藏 3
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 图的存储

http://blog.csdn.net/u010721079/article/details/26101885

#include <iostream>
using std::cin;
using std::cout;
using std::endl;
#include<string.h>
#define INFINITY 0                          //两个顶点之间无边或弧时的数值
#define MAX_VERTEX_NUM 26                   //最大顶点个数
#define MAX_INFO    10                      //弧相关信息的字符串的最大长度
#define TRUE  1
#define FALSE 0
#define ERROR 0
#define OK    1
typedef int Status;
typedef int VRType;                        //顶点关系类型
typedef char InfoType;
typedef char VertexType[MAX_VERTEX_NUM];   //顶点类型    
enum GraphKind{DG,DN,UDG,UDN};

//有向图，有向网，无向图，无线网
typedef struct
{
    VRType adj;                        // VRType是顶点关系类型，对无权图，用1或0
                                       //表示相邻否，对带权图，则为权值类型
        InfoType *info;                    //  该弧相关信息的指针
}ArcCell, AdjMartix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef struct
{ 
    VertexType vexs[MAX_VERTEX_NUM];   //顶点向量
    AdjMartix arcs;                    //邻接矩阵
        int vexnum,arcnum;                 //图的当前顶点个数和弧数
    GraphKind kind;                    //图的种类标志
}MGraph;
int LocateVex(MGraph G,VertexType u)       //若图中存在顶点u，则返回该顶点在图中的位置；否则返回其他信息
{
    for(int i = 0; i < G.vexnum; ++i)
        if(strcmp(u,G.vexs[i]) == 0)
            return i;
       return -1;
}
Status CreateDG(MGraph &G)                 //采用数组（邻接矩阵）表示法，构造有向图
{
    int i,j,k,l,IncInfo;
    char a[MAX_INFO];
    VertexType va,vb;
    cout << "**********************************有向图*************************************" << endl;
    cout << "请输入有向图的顶点数，边数，以及边是否含有其它信息（是：1，否：0）：" << endl;
    cout << "请输入顶点数： ";
    cin >> G.vexnum;
    cout << "请输入弧数： " << endl;
    cin >> G.arcnum ;
    cout << "请输入边是否含有其它信息（是：1，否：0）： " << endl;
    cin >> IncInfo;
    cout << "开始构造有向图：\n" << "逐一输入顶点向量" << endl;
    for(i = 0;i < G.vexnum;++i)
    {
        cout << "请输入第"<<i+1<<"个顶点的向量: "<<endl;
        cin >> G.vexs[i] ;

    }
    for(i = 0; i < G.vexnum; ++i)                                                           //初始化邻接矩阵
        for(j = 0; j < G.vexnum; ++j)
        {
            G.arcs[i][j].adj = INFINITY;                                            //有向图
            G.arcs[i][j].info = NULL;
        }
        cout << "请输入"  << G.arcnum << "条弧的弧头和弧尾" << endl;
        for(k = 0; k < G.arcnum; ++k)
        {       
            cout << "请输入第" << k + 1 << "条弧的弧尾：" << endl;
            cin >> va ;
            cout << "请输入第" << k + 1 << "条弧的弧头：" << endl;
            cin >> vb;
            i = LocateVex(G,va);
            j = LocateVex(G,vb);
            G.arcs[i][j].adj = 1;          //有向图
            if(IncInfo)
            {
                cout << "请输入该边的相关信息(" << MAX_INFO  << "个字符）";
                cin >> a;
                l = strlen(a);
                if(l)
                {
                    G.arcs[i][j].info = (char *)malloc( (l+1)*sizeof(char) ); //有向图
                    strcpy(G.arcs[i][j].info,a);
                }
            }
        }
        G.kind = DG;
        return OK;
}
Status CreateDN(MGraph &G)                                                                        //采用数组（邻接矩阵），构造有向网
{
    int i, j, k, w, IncInfo;
    char a[MAX_INFO];
    VertexType va,vb;
    cout << "**********************************有向网*************************************" << endl;
    cout << "请输入有向网的顶点数，弧数、权值以及边是否含有其它信息（是：1，否：0）：" << endl;
    cout << "请输入顶点数： ";
    cin >> G.vexnum;
    cout << "请输入弧数： " << endl;
    cin >> G.arcnum ;
    cout << "请输入边是否含有其它信息（是：1，否：0）： " << endl;
    cin >> IncInfo;
    cout << "开始构造有向网： \n" << "逐一输入顶点向量" << endl;
    for(i = 0;i < G.vexnum;++i)
    {
        cout << "请输入第"<<i+1<<"个顶点的向量: "<<endl;
        cin >> G.vexs[i] ;

    }
    for(i = 0; i < G.vexnum; ++i)                                                              //初始化邻接矩阵
        for(j = 0; j < G.vexnum; ++j)
        {
            G.arcs[i][j].adj = INFINITY;                                               //有线网
            G.arcs[i][j].info = NULL;
        }
        cout << "请输入"  << G.arcnum << "条弧的弧尾、弧头和权值" << endl;
        for(k = 0; k < G.arcnum; ++k)
        {

            cout << "请输入第" << k + 1 << "条弧的弧尾：" << endl;
            cin >> va ;
            cout << "请输入第" << k + 1 << "条弧的弧头：" << endl;
            cin >> vb;
            cout << "请输入该弧的权值： " << endl;
            cin >> w;
            i = LocateVex(G,va);
            j = LocateVex(G,vb);
            G.arcs[i][j].adj = w;                                                      //有向网
            if(IncInfo)
            {
                cout << "请输入该边的相关信息(" << MAX_INFO  << "个字符）";
                cin >> a;
                w = strlen(a);
                if(w)
                {
                    G.arcs[i][j].info = (char *)malloc((w+1)*sizeof(char));    //有向网
                    strcpy(G.arcs[i][j].info,a);
                }
            }
        }
        G.kind = DN;
        return OK;
}

Status CreateUDG(MGraph &G)                                                                        //用数组（邻接矩阵）表示法，构造无向图
{
   int i,j,k,l,IncInfo;
   char a[MAX_INFO];
   VertexType va,vb;
   cout << "**********************************无向图*************************************" << endl;
   cout << "请输入无向图的顶点数，边数，以及边是否含有其它信息（是：1，否：0）：" << endl;
   cout << "请输入顶点数： ";
   cin >> G.vexnum;
   cout << "请输入边数： " << endl;
   cin >> G.arcnum ;
   cout << "请输入边是否含有其它信息（是：1，否：0）： " << endl;
   cin >> IncInfo;
   cout << "开始构造无向图： \n" << "逐一输入顶点向量……" << endl;
   for(i = 0;i < G.vexnum;++i)
   {
      cout << "请输入第"<<i+1<<"个顶点的向量: "<<endl;
      cin >> G.vexs[i] ;

   }
   for(i = 0; i < G.vexnum; ++i)                                                                   //初始化邻接矩阵
    for(j = 0; j < G.vexnum; ++j)
      {
              G.arcs[i][j].adj = INFINITY;
              G.arcs[i][j].info = NULL;
      }
    for (k = 0; k < G.arcnum; ++k)
    {

        cout << "请输入第" << k + 1 << "条边的第一个顶点：" << endl;
        cin >> va ;
        cout << "请输入第" << k + 1 << "条边的第二个顶点：" << endl;
            cin >> vb;
        i = LocateVex(G,va);
        j = LocateVex(G,vb);
        G.arcs[i][j].adj = G.arcs[j][i].adj = 1;                                           // 无向图
        if(IncInfo)
        {
                  cout << "请输入该边的相关信息(" << MAX_INFO  << "个字符）";
          cin >> a;
          l = strlen(a);
          if (l)
          {
              G.arcs[i][j].info = G.arcs[j][i].info = (char *)malloc( (l + 1)*sizeof(char) );  //给相关信息分配内存空间
              strcpy(G.arcs[i][j].info,a);
          }                                                                                        //无向图，两个指针指向同一个信息
        }
    }
    G.kind = UDG;
    return OK;
}
Status CreateUDN(MGraph &G)                                                                                //采用数组（邻接矩阵）表示法，构造无向网
{
    int i,j,k,w,IncInfo;
    char a[MAX_INFO];
    VertexType va,vb;
    cout << "**********************************无向网*************************************" << endl;
    cout << "请输入无向网的顶点数、边数和权值，以及边是否含有其它信息（是：1，否：0）：" << endl;
    cout << "请输入顶点数： ";
    cin >> G.vexnum;
    cout << "请输入边数： " << endl;
    cin >> G.arcnum ;
    cout << "请输入边是否含有其它信息（是：1，否：0）： " << endl;
     cin >> IncInfo;
    cout << "开始构造无向网： \n" << "逐一输入顶点向量" << endl;

    for(i = 0;i < G.vexnum;++i)
    {
        cout << "请输入第"<<i+1<<"个顶点的向量: "<<endl;
        cin >> G.vexs[i] ;

    }
    for(i = 0; i < G.vexnum; ++i)                                                                          //初始化邻接矩阵
        for(j = 0; j < G.vexnum; ++j)
        {
            G.arcs[i][j].adj = INFINITY;                                                           //无线网
            G.arcs[i][j].info = NULL;
        }

    for (k = 0; k < G.arcnum; ++k)
    {
        cout << "请输入第" << k + 1 << "条边的第一个顶点：" << endl;
        cin >> va ;
        cout << "请输入第" << k + 1 << "条边的第二个顶点：" << endl;
        cin >> vb;
        cout << "请输入该边的权值： " << endl;
        cin >> w;
        i =LocateVex(G,va);
        j =LocateVex(G,vb);
        G.arcs[i][j].adj = G.arcs[j][i].adj = w;                                                       //无向网
        if (IncInfo)
        {
            cout << "请输入该边的相关信息(" << MAX_INFO  << "个字符）";
            cin >> a;
            w = strlen(a);
            if (w)
            {
                G.arcs[i][j].info = G.arcs[j][i].info = (char *)malloc((w+1)*sizeof(char));   //无向网，两个指针指向同一个信息
                strcpy(G.arcs[i][j].info,a);
            }
        }
    }
    G.kind = UDN;
    return OK;
}


Status CreateGraph(MGraph &G)
{
    cout << "请输入图G的类型\n"  << "有向图：0\n" 
                             << "有向网：1\n"
                     << "无向图：2\n"
                     << "无向网：3\n";
    scanf("%d",&G.kind);
    switch(G.kind)
    {
    case DG:  CreateDG(G);       //有向图
          break;
    case DN:  CreateDN(G);       //有向网
          break;
    case UDG: CreateUDG(G);      //无向图
          break;
    case UDN: CreateUDN(G);      //无向网
          break;
    }
    return OK;
}
Status DestroyGraph(MGraph &G)     //若图存在，则销毁图G
{
    int i,j,k = 0;
    if(G.kind % 2)             // 网
        k = INFINITY;      // K为两顶点之间无边或无弧时邻接矩阵元素的值
    for(i = 0; i < G.vexnum; ++i)
        if(G.kind < 2)  //有向
        {
                  for(j = 0; j < G.vexnum; ++j)
               if(G.arcs[i][j].adj != k)    //两顶点之间有弧
                   if(G.arcs[i][j].info)
                   {
                       free(G.arcs[i][j].info);
                       G.arcs[i][j].info = NULL;    
                   }
        }
            else
        {
               for (j = i + 1; j < G.vexnum; ++j)
               {
                   if (G.arcs[i][j].adj != k)
                       if(G.arcs[i][j].info)
                   {
                                    free(G.arcs[i][j].info);
                    G.arcs[i][j].info = G.arcs[j][i].info = NULL;
                   }
               }
        }
        G.vexnum = 0;
        G.vexnum = 0;

    return OK;
}
void Display(MGraph &G)
{
     for(int i = 0; i < G.vexnum; ++i)
         for(int j = 0; j < G.vexnum; ++j)
     {
         cout << G.arcs[i][j].adj << ' ';
     if((j+1)%G.vexnum == 0)
         cout << endl;
     }
}
int main()
{
     int i,j,k,n;
     MGraph G;
     CreateGraph( G);
     Display(G);
     DestroyGraph(G);
    return 0;
}
奔跑吧犀牛
关注
专栏目录
图的存储结构01—数组表示法
weixin_42681308的博客
08-17 604
图的数组(邻接矩阵)存储表示 代码实现(C语言) 定义邻接矩阵 // ----- 图的数组(邻接矩阵)存储表示 ----- typedef int VRType; //顶点关系类型，无权图用1或0表示相邻否，带权图则为权值类型 typedef char* InfoType; //弧/边相关信息 typedef int VertexType; #define INFINITY INT_...
【数据结构】算法7.1-7.2 图的存储结构-数组表示法
Zelda 的博客
10-10 1329
#include<stdio.h> #include<string.h> #include<stdlib.h>#define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2#define INFINITY 65535 //最大值∞ #define MAX_
图的存储结构之数组表示法
u010561005的专栏
05-20 1547
由于图中顶点间的关系(弧或边)无规律，故对图的存储较之表或树要复杂的多，需要根据图的具体应用来构造图的存储结构。 常用的存储表示有“数组表示法”、“邻接表”、“十字链表”和“邻接多重表”。   数组表示法 图的数组表示法又称“邻接矩阵”(Adjacency Matrix)表示法。   G = (V，R) 用两个数组来存储图G： 一个数组(一维)存储G中顶点集合V；另一个数组(二维)映像
图的存储结构—数组表示法
孤木不成林
12-08 1954
邻接矩阵G[N][N]——n个顶点从0到n-1编号                                         1 若&lt;vi,vj&gt;是G中的边                  G[i][j]                                       0 若&lt;vi,vj&gt;不是G中的边 对有向图G1的邻接矩阵表示      ...
1、 掌握图的结构特征以及四种存储结构（数组表示法、邻接表、十字链表和邻接多重表）的特点和程序设计方法。
09-10
二、 实验要求 1、 定义邻接矩阵存储结构或邻接表存储结构。 2、 按照建立一个带权有向图的操作需要，编写在邻接矩阵或邻接表存储结构下，带权有向图基本操作的实现函数（如初始化图、在图中插入一个结点、在图中插入一条边、在图中寻找序号为v的结点的第一个邻接结点、在图中寻找序号为v1结点的邻接结点v2的下一个邻接结点、图的深度优先遍历、图的广度优先遍历等。 3、 设计一个测试主函数，通过键盘输入图的顶点和边信息创建一个图（有n个结点和e条边）。然后打印图的n个结点信息和e条边信息，最后分别打印出图的深度优先遍历和广度优先遍历的结点信息序列。
数据结构：数组PPT学习教案.pptx
10-08
数据结构中的数组是一种基础且重要的概念，它是一种特殊的线性表，其中的每个元素本身也是一个线性表。数组的特殊之处在于，它具有固定的大小和特定的索引系统，允许快速访问任何位置的元素。多维数组是数组的扩展，...
图的数组表示法c语言版,数据结构——图的数组（邻接矩阵）表示法
weixin_29503445的博客
05-21 955
数组表示无向图用两个数组(vexs[],arcs[][])分别存储数据元素(顶点)的信息和数据元素之间的关系(边或弧)的信息。以二维数组表示有n个顶点的图时，需存放n个顶点信息和n^2个弧信息存储量。若考虑无向图的邻接矩阵的对称性，则可采用压缩存储的方式只存入矩阵的下三角(或上三角)元素。下示算法时在邻接矩阵存储结构MGraph上对图构造的实现框架，它根据G的种类调用具体构造的算法。例如G为无向图...
C语言程序设计_哈工大（3）：数组的编程实训.pdf1
08-03
- **数组下标**：数组的下标是从0开始的，表示数组元素的位置，例如，一个长度为n的数组，其下标范围是0到n-1。 - **存储方式**：数组在内存中是连续存储的，这意味着可以通过数组名和下标快速访问任意元素，因为...
C语言：数组的应用实验报告.pdf
04-10
在C语言中，数组是一种非常基础且重要的数据结构，它允许程序员存储一组具有相同类型的数据。在这个实验报告中，我们看到了四个不同的C语言程序，它们分别展示了数组在不同场景下的应用，包括一维数组和二维数组的...
图的数组表示法和邻接表表示法及运用
04-14
1、构造图的两种存储方式 3、输出两种存储方式，并进行转化，看是否得到了正确的结果 4、在邻接表的基础上实现图的遍历操作 5、编写图的最小生成树算法，并进行验证 6、编写最短路径算法，并对输入的图进行验证
数组的表示方法
热门推荐
weixin_45602105的博客
09-28 1万+
一，C语言中的数组： 类型说明符 数组名 [常量表达式]; 数组长度一旦声明,不可改变不可追加 声明一个int类型的数组 如： int[ ] arr; 或int arr[ ]; 给数组分配空间 arr=new int[5]; 给数组赋值 arr[0]=1; 0代表的是数组的第1个元素 ,元素下标为0 arr[1]=1; 1代表的是数组的第2个元素 ,元素下...
学习记录——数组的六种表示法
A765422804的博客
12-09 2013
int b[] = { 4,5,3,6,2,5,1 }; int *bPtr = b; //另一种表达方式 int *bPtr = &b[]; //数组下标 for (int i = 0; i < 7; i++) { cout << b[i] ; } cout << endl; //内置数组做指针的偏移量表示法 for (int i = 0; i < 7; i++) { cout << *(b + i) ; }..
数组的概述及内存图
wangkexiang21的博客
03-28 410
数组概念：数组是存储同一种数据类型多个元素的集合 一维数组定义格式：数据类型 [] 数组名；或者 数据类型 数组名 [] 数组的初始化：初始化就是给数组中元素分配内存空间，并赋值。因为Java中数组必须先初始化，然后才能使用。初始化分两种：一种是静态初始化：给出初始化的值，让系统决定长度。格式为，数据类型[] 数组名 = {元素1,元素2,…}; 如（int [ ] arr ={1,3,4,5,6};）,另一种是动态初始化：只指定长度，由系统给出初始值。格式为，数据类型[] 数组名 ...
12.图——数组表示法
StaticMan
03-13 6074
无向图：V是顶点的集合，VR是弧的集合，弧用(顶点，顶点)表示。有n个顶点，n(n-1)/2条弧的图，是无向完全图。 权：图的弧的相关系数。 网：带权的图。 子图：顶点和弧都包含于原图的图 邻接：两顶点之间有弧，则无向图a、b互为邻接点，有向图a邻接到b。 依附：弧依附于其两个顶点。 顶点的度：与顶点相关联的弧的个数。有向图有入度、出度之分。 路径：从a到b途径顶点组成的序列。有向图
学习笔记：图的基本概念和存储方式
张小憨憨的博客
12-21 786
图的基本概念和存储方式图的基本概念和存储方式图的基本概念图的存储方式图的邻接矩阵表示法（数组表示法）图的邻接表表示法（链式存储法）图的十字链表表示法（链式存储法）无向图的邻接多重表表示法 图的基本概念和存储方式 图的基本概念 图(Graph)是一种较线性表和树更为复杂的数据结构。 在线性结构中，数据元素之间仅存在线性关系。 在树型结构中，数据元素之间存在明显的一对多的层次关系。 而在图型结构中，结点之间是多对多的任意关系。 图的结构定义： 图是由顶点集V和弧集R构成的数据结构。Graph = (V,R) 其
图解数据结构(01) -- 数组
姜皓的博客
12-26 1587
数组 1、什么是数组 数组对应的英文是 array，是有限个相同类型的变量所组成的有序集合，数组中 的每一个变量被称为元素。数组是最为简单、最为常用的数据结构；以整型数组为例，数组的存储形式如下图所示： 数组中的每一个元素有着自己的下标，只不过这个下标从0开始，一直到数组长度-1；数组的另一个特点，是在内存中顺序存储，因此可以很好地实现逻辑上的顺序表。 数组在内存中的顺序存储：内存是由一个个连续...
C语言 -- 数组
最新发布
nopd的学习经历
06-01 403
以上就是今天要讲的内容，本文仅仅简单介绍了C语言数组部分知识。如有错漏，望批评指正。让我们共同进步吧！！
图的存储 ——边集数组 & 邻接表
谢谢你们的关注
09-30 1137
图的存储 ——边集数组 & 邻接表
数据结构精要：数组与广义表的存储
三元组表示法将非零元素存储为 (行号, 列号, 值) 的形式，适合矩阵运算，但不便于按行或列访问。 广义表是另一种灵活的数据结构，它可以包含其他列表作为元素，即它允许嵌套。广义表的存储表示通常使用链式结构，如...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值