第十二周 项目2-操作用邻接表存储的图

最新推荐文章于 2020-02-03 23:33:34 发布
最新推荐文章于 2020-02-03 23:33:34 发布
阅读量261 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxt17853535692/article/details/53143290
版权

问题描述及代码：

/*  
Copyright (c)2015,烟台大学计算机与控制工程学院  
All rights reserved.  
文件名称：邻接表存储的图.cpp  
作    者：张晓彤 
完成日期：2016年11月12日  
版 本 号：v1.0  
问题描述: 假设图G采用邻接表存储，分别设计实现以下要求的算法   
输入描述：若干测试数据。  
程序输出：DFS,BFS的遍历序列。   
*/    
  
1、头文件graph.h中定义相关的数据结构并声明用于完成基本运算的函数。对应基本运算的函数包括：    
    void ArrayToMat(int *Arr, int n, MGraph &g); //用普通数组构造图的邻接矩阵   
    void ArrayToList(int *Arr, int n, ALGraph *&); //用普通数组构造图的邻接表   
    void MatToList(MGraph g,ALGraph *&G);//将邻接矩阵g转换成邻接表G   
    void ListToMat(ALGraph *G,MGraph &g);//将邻接表G转换成邻接矩阵g   
    void DispMat(MGraph g);//输出邻接矩阵g   
    void DispAdj(ALGraph *G);//输出邻接表G       
2、在graph.cpp中实现这些函数   
3、用main.cpp中的main函数中完成测试。      
* 输入描述： 无    
* 程序输出： 测试数据    
*/
graph.h头文件代码 

#ifndef GRAPH_H_INCLUDED    
#define GRAPH_H_INCLUDED    
#include <stdio.h>    
#include <malloc.h>    
#define MAXV 100                //最大顶点个数    
#define INF 32767       //INF表示∞    
typedef int InfoType;    
  
  
//以下定义邻接矩阵类型    
typedef struct    
{    
    int no;                     //顶点编号    
    InfoType info;              //顶点其他信息，在此存放带权图权值    
} VertexType;                   //顶点类型    
typedef struct                  //图的定义    
{    
    int edges[MAXV][MAXV];      //邻接矩阵    
    int n,e;                    //顶点数，弧数    
    VertexType vexs[MAXV];      //存放顶点信息    
} MGraph;                       //图的邻接矩阵类型    
//以下定义邻接表类型    
typedef struct ANode            //弧的结点结构类型    
{    
    int adjvex;                 //该弧的终点位置    
    struct ANode *nextarc;      //指向下一条弧的指针    
    InfoType info;              //该弧的相关信息,这里用于存放权值    
} ArcNode;    
typedef int Vertex;    
typedef struct Vnode            //邻接表头结点的类型    
{    
    Vertex data;                //顶点信息    
    int count;                  //存放顶点入度,只在拓扑排序中用    
    ArcNode *firstarc;          //指向第一条弧    
} VNode;    
typedef VNode AdjList[MAXV];    //AdjList是邻接表类型    
typedef struct    
{    
    AdjList adjlist;            //邻接表    
    int n,e;                    //图中顶点数n和边数e    
} ALGraph;                      //图的邻接表类型    
//功能：由一个反映图中顶点邻接关系的二维数组，构造出用邻接矩阵存储的图    
//参数：Arr - 数组名，由于形式参数为二维数组时必须给出每行的元素个数，在此将参数Arr声明为一维数组名（指向int的指针）    
//      n - 矩阵的阶数    
//      g - 要构造出来的邻接矩阵数据结构    
void ArrayToMat(int *Arr, int n, MGraph &g); //用普通数组构造图的邻接矩阵    
void ArrayToList(int *Arr, int n, ALGraph *&); //用普通数组构造图的邻接表    
void MatToList(MGraph g,ALGraph *&G);//将邻接矩阵g转换成邻接表G    
void ListToMat(ALGraph *G,MGraph &g);//将邻接表G转换成邻接矩阵g    
void DispMat(MGraph g);//输出邻接矩阵g    
void DispAdj(ALGraph *G);//输出邻接表G    
#endif // GRAPH_H_INCLUDED 
//图基本运算函数    
#include "graph.h"    
//功能：由一个反映图中顶点邻接关系的二维数组，构造出用邻接矩阵存储的图    
//参数：Arr - 数组名，由于形式参数为二维数组时必须给出每行的元素个数，在此将参数Arr声明为一维数组名（指向int的指针）    
//      n - 矩阵的阶数    
//      g - 要构造出来的邻接矩阵数据结构    
void ArrayToMat(int *Arr, int n, MGraph &g)    
{    
    int i,j,count=0;  //count用于统计边数，即矩阵中非0元素个数    
    g.n=n;    
    for (i=0; i<g.n; i++)    
        for (j=0; j<g.n; j++)    
        {    
            g.edges[i][j]=Arr[i*n+j]; //将Arr看作n×n的二维数组，Arr[i*n+j]即是Arr[i][j]，计算存储位置的功夫在此应用    
            if(g.edges[i][j]!=0)    
                count++;    
        }    
    g.e=count;    
}    
  
  
void ArrayToList(int *Arr, int n, ALGraph *&G)    
{    
    int i,j,count=0;  //count用于统计边数，即矩阵中非0元素个数    
    ArcNode *p;    
    G=(ALGraph *)malloc(sizeof(ALGraph));    
    G->n=n;    
    for (i=0; i<n; i++)                 //给邻接表中所有头节点的指针域置初值    
        G->adjlist[i].firstarc=NULL;    
    for (i=0; i<n; i++)                 //检查邻接矩阵中每个元素    
        for (j=n-1; j>=0; j--)    
            if (Arr[i*n+j]!=0)      //存在一条边，将Arr看作n×n的二维数组，Arr[i*n+j]即是Arr[i][j]    
            {    
                p=(ArcNode *)malloc(sizeof(ArcNode));   //创建一个节点*p    
                p->adjvex=j;    
                p->info=Arr[i*n+j];    
                p->nextarc=G->adjlist[i].firstarc;      //采用头插法插入*p    
                G->adjlist[i].firstarc=p;    
            }    
    G->e=count;    
}    
  
  
void MatToList(MGraph g, ALGraph *&G)    
//将邻接矩阵g转换成邻接表G    
{    
    int i,j;    
    ArcNode *p;    
    G=(ALGraph *)malloc(sizeof(ALGraph));    
    for (i=0; i<g.n; i++)                   //给邻接表中所有头节点的指针域置初值    
        G->adjlist[i].firstarc=NULL;    
    for (i=0; i<g.n; i++)                   //检查邻接矩阵中每个元素    
        for (j=g.n-1; j>=0; j--)    
            if (g.edges[i][j]!=0)       //存在一条边    
            {    
                p=(ArcNode *)malloc(sizeof(ArcNode));   //创建一个节点*p    
                p->adjvex=j;    
                p->info=g.edges[i][j];    
                p->nextarc=G->adjlist[i].firstarc;      //采用头插法插入*p    
                G->adjlist[i].firstarc=p;    
            }    
    G->n=g.n;    
    G->e=g.e;    
}    
  
  
void ListToMat(ALGraph *G,MGraph &g)    
//将邻接表G转换成邻接矩阵g    
{    
    int i,j;    
    ArcNode *p;    
    for (i=0; i<g.n; i++)   //先初始化邻接矩阵    
        for (j=0; j<g.n; j++)    
            g.edges[i][j]=0;    
    for (i=0; i<G->n; i++)  //根据邻接表，为邻接矩阵赋值    
    {    
        p=G->adjlist[i].firstarc;    
        while (p!=NULL)    
        {    
            g.edges[i][p->adjvex]=p->info;    
            p=p->nextarc;    
        }    
    }    
    g.n=G->n;    
    g.e=G->e;    
}    
void DispMat(MGraph g)    
//输出邻接矩阵g    
{    
    int i,j;    
    for (i=0; i<g.n; i++)    
    {    
        for (j=0; j<g.n; j++)    
            if (g.edges[i][j]==INF)    
                printf("%3s","∞");    
            else    
                printf("%3d",g.edges[i][j]);    
        printf("\n");    
    }    
}    
void DispAdj(ALGraph *G)    
//输出邻接表G    
{    
    int i;    
    ArcNode *p;    
    for (i=0; i<G->n; i++)    
    {    
        p=G->adjlist[i].firstarc;    
        printf("%3d: ",i);    
        while (p!=NULL)    
        {    
            printf("-->%d/%d ",p->adjvex,p->info);    
            p=p->nextarc;    
        }    
        printf("\n");    
    }    
}
（1）输出出图G中每个顶点的出度代码： 

#include "graph.h"    
  
  
//返回图G中编号为v的顶点的出度    
int OutDegree(ALGraph *G,int v)    
{    
    ArcNode *p;    
    int n=0;    
    p=G->adjlist[v].firstarc;    
    while (p!=NULL)    
    {    
        n++;    
        p=p->nextarc;    
    }    
    return n;    
}    
//输出图G中每个顶点的出度    
void OutDs(ALGraph *G)    
{    
    int i;    
    for (i=0; i<G->n; i++)    
        printf("  顶点%d:%d\n",i,OutDegree(G,i));    
}    
int main()    
{    
    ALGraph *G;    
    int A[7][7]=    
    {    
        {0,1,1,1,0,0,0},    
        {0,0,0,0,1,0,0},    
        {0,0,0,0,1,1,0},    
        {0,0,0,0,0,0,1},    
        {0,0,0,0,0,0,0},    
        {0,0,0,1,1,0,1},    
        {0,1,0,0,0,0,0}    
    };    
    ArrayToList(A[0], 7, G);    
    printf("各顶点出度:\n");    
    OutDs(G);    
    return 0;    
}
运行结果：

（２）求出图G中出度最大的一个顶点，输出该顶点编号代码：

#include "graph.h"    
  
  
//返回图G中编号为v的顶点的出度    
int OutDegree(ALGraph *G,int v)    
{    
    ArcNode *p;    
    int n=0;    
    p=G->adjlist[v].firstarc;    
    while (p!=NULL)    
    {    
        n++;    
        p=p->nextarc;    
    }    
    return n;    
}    
  
  
//输出图G中每个顶点的出度    
void OutDs(ALGraph *G)    
{    
    int i;    
    for (i=0; i<G->n; i++)    
        printf("  顶点%d:%d\n",i,OutDegree(G,i));    
}    
  
  
//输出图G中出度最大的一个顶点    
void OutMaxDs(ALGraph *G)    
{    
    int maxv=0,maxds=0,i,x;    
    for (i=0; i<G->n; i++)    
    {    
        x=OutDegree(G,i);    
        if (x>maxds)    
        {    
            maxds=x;    
            maxv=i;    
        }    
    }    
    printf("顶点%d，出度=%d\n",maxv,maxds);    
}    
  
  
int main()    
{    
    ALGraph *G;    
    int A[7][7]=    
    {    
        {0,1,1,1,0,0,0},    
        {0,0,0,0,1,0,0},    
        {0,0,0,0,1,1,0},    
        {0,0,0,0,0,0,1},    
        {0,0,0,0,0,0,0},    
        {0,0,0,1,1,0,1},    
        {0,1,0,0,0,0,0}    
    };    
    ArrayToList(A[0], 7, G);    
  
  
    printf("最大出度的顶点信息:");    
    OutMaxDs(G);    
  
  
    return 0;    
}
运行结果：


（3）计算图G中出度为0的顶点数；代码：

#include "graph.h"    
//返回图G中编号为v的顶点的出度    
int OutDegree(ALGraph *G,int v)    
{    
    ArcNode *p;    
    int n=0;    
    p=G->adjlist[v].firstarc;    
    while (p!=NULL)    
    {    
        n++;    
        p=p->nextarc;    
    }    
    return n;    
} //输出图G中每个顶点的出度    
void OutDs(ALGraph *G)    
{    
    int i;    
    for (i=0; i<G->n; i++)    
        printf("  顶点%d:%d\n",i,OutDegree(G,i));    
}  //输出图G中出度为0的顶点数    
void ZeroDs(ALGraph *G)    
{    
    int i,x;    
    for (i=0; i<G->n; i++)    
    {    
        x=OutDegree(G,i);    
        if (x==0)    
            printf("%2d",i);    
    }    
    printf("\n");    
}    
  
  
int main()    
{    
    ALGraph *G;    
    int A[7][7]=    
    {    
        {0,1,1,1,0,0,0},    
        {0,0,0,0,1,0,0},    
        {0,0,0,0,1,1,0},    
        {0,0,0,0,0,0,1},    
        {0,0,0,0,0,0,0},    
        {0,0,0,1,1,0,1},    
        {0,1,0,0,0,0,0}    
    };    
    ArrayToList(A[0], 7, G);    
  
  
    printf("出度为0的顶点:");    
    ZeroDs(G);    
  
  
    return 0;    
}
运行结果： 


#include "graph.h"    
//返回图G中编号为v的顶点的出度    
int OutDegree(ALGraph *G,int v)    
{    
    ArcNode *p;    
    int n=0;    
    p=G->adjlist[v].firstarc;    
    while (p!=NULL)    
    {    
        n++;    
        p=p->nextarc;    
    }    
    return n;    
}    
  
  
//输出图G中每个顶点的出度    
void OutDs(ALGraph *G)    
{    
    int i;    
    for (i=0; i<G->n; i++)    
        printf("  顶点%d:%d\n",i,OutDegree(G,i));    
}    
  
  
//输出图G中出度最大的一个顶点    
void OutMaxDs(ALGraph *G)    
{    
    int maxv=0,maxds=0,i,x;    
    for (i=0; i<G->n; i++)    
    {    
        x=OutDegree(G,i);    
        if (x>maxds)    
        {    
            maxds=x;    
            maxv=i;    
        }    
    }    
    printf("顶点%d，出度=%d\n",maxv,maxds);    
}    
//输出图G中出度为0的顶点数    
void ZeroDs(ALGraph *G)    
{    
    int i,x;    
    for (i=0; i<G->n; i++)    
    {    
        x=OutDegree(G,i);    
        if (x==0)    
            printf("%2d",i);    
    }    
    printf("\n");    
}    
  
  
//返回图G中是否存在边<i,j>    
bool Arc(ALGraph *G, int i,int j)    
{    
    ArcNode *p;    
    bool found = false;    
    p=G->adjlist[i].firstarc;    
    while (p!=NULL)    
    {    
        if(p->adjvex==j)    
        {    
            found = true;    
            break;    
        }    
        p=p->nextarc;    
    }    
    return found;    
}    
  
  
int main()    
{    
    ALGraph *G;    
    int A[7][7]=    
    {    
        {0,1,1,1,0,0,0},    
        {0,0,0,0,1,0,0},    
        {0,0,0,0,1,1,0},    
        {0,0,0,0,0,0,1},    
        {0,0,0,0,0,0,0},    
        {0,0,0,1,1,0,1},    
        {0,1,0,0,0,0,0}    
    };    
    ArrayToList(A[0], 7, G);    
  
  
    printf("边<2,6>存在吗？");    
    if(Arc(G,2,6))    
        printf("是\n");    
    else    
        printf("否\n");    
    printf("\n");    
  
  
    return 0;    
}
运行结果：


知识点总结：
   图算法库的应用。
学习心得：
   通过邻接表存储的图比邻接矩阵更加的节省空间，是一种顺序分配与链式分配相结合的存储方式。







zxt17853535692
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
假设图中数据元素类型是字符型，请采用邻接矩阵或邻接表实现图的以下基本操作： （1）构造图（包括有向图、有向网、无向图、无向网）； （2）根据深度优先遍历图。
06-09
1、图和网的区别：网是带权值的图 有向和无向的区别：有向直接标出谁指向谁，无向是有向的特例，有弧，说明也有弧。 构图： ①　确定顶点数，弧数，是否有权值 ②　输入每个顶点，弧，权值 ③　若是无向，则需实现弧与的同置 2、图的深度优先搜索遍历类似于树的先根遍历，沿着初始顶点出发的一条路径，尽可能深入地前进，直到所有顶点被访问完；用visited[]来存储顶点的访问情况，初始时所有顶点皆为未访问FALSE，访问一个顶点之后就被标记为已访问TRUE。
图的存储和遍历实验
呓语程序缘
11-01 2594
一、实验目的 1、掌握图的邻接矩阵和邻接表的存储和表示。 2、掌握图的一些基本应用。 3、掌握图的遍历方法。 4、掌握图的最小生成树算法。 5、掌握图的最短路径 Dijkstra 算法。 二、实验内容 1、采用邻接表存储图（要求完成）。 2、输入图并构造邻接矩阵（要求完成）。 3、采用深度优先和广度优先遍历图（要求完成）。 #include <stdio.h> #include <stdlib.h> #define Maxint 10000 //表示极大值 #define MVN
实现图的邻接矩阵和邻接表的存储
追溯的博客
11-30 1万+
编写一个程序graph.cpp，设计带权图的邻接矩阵和邻接表的创建和输出运算（包括邻接矩阵和邻接表之间的转换）  //图的基本运算算法 #include #include //图的两种存储结构 #define INF 32767    //定义∞ #define MAXV 100    //最大顶点个数 typedef char InfoType; //以下定义邻接矩阵类
【第十一周】数据结构实践——操作用邻接表存储的图
ljj19971222的博客
11-16 221
*Copyright (c)2017,烟台大学计算机与控制工程学院 *All rights reserved. *文件名称： *作 者：李佳骏 *完成日期：2017年11月16日 *版 本 号：v1.0
（数据结构）1.实现图的邻接矩阵和邻接表的存储 2.实现图的遍历算法
weixin_41032720的博客
07-06 2万+
实验内容 1、编写一个程序graph.cpp，设计带权图的邻接矩阵与邻接表的创建和输出运算，并在此基础上设计一个主程序exp8-1.cpp完成以下功能。 （1）建立如图8.54所示的有向图G的邻接矩阵，并输出之。 （2）建立如图8.54所示的有向图G的邻接表，并输出之。 （3）销毁图G的邻接表。 2、编写一个程序travsal.cpp实现图的两种遍历运算，并在此基础上设计一个程序exp8-2.cp...
1、 掌握图的结构特征以及四种存储结构（数组表示法、邻接表、十字链表和邻接多重表）的特点和程序设计方法
10-29
2、 按照建立一个带权有向图的操作需要，编写在邻接矩阵或邻接表存储结构下，带权有向图基本操作的实现函数（如初始化图、在图中插入一个结点、在图中插入一条边、在图中寻找序号为v的结点的第一个邻接结点、在图中...
1、 掌握图的结构特征以及四种存储结构（数组表示法、邻接表、十字链表和邻接多重表）的特点和程序设计方法。
09-10
2、 按照建立一个带权有向图的操作需要，编写在邻接矩阵或邻接表存储结构下，带权有向图基本操作的实现函数（如初始化图、在图中插入一个结点、在图中插入一条边、在图中寻找序号为v的结点的第一个邻接结点、在图中...
数据结构习题答案(全部算法)严蔚敏版
11-18
7.7.1 无向图的邻接表的建立和遍历 7.7.2 有向无环图的拓扑排序和求关键路径 习题七 第8章 查找 8.1 基本概念 8.2 静态表查找 8.2.1 顺序表的查找 8.2.2 有序表的查找 8.2.3 索引顺序表的查找 8.3 动态查找...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
《计算机世界》报组织的“世纪评选”把他评为我国“20世纪最有影响的IT人物”10个人之一（排在第2位）。他的功绩是把千百万群众带入计算机的大门。 1 C语言概述 1.1 Ｃ语言的发展过程 1.2 当代最优秀的程序设计语言 ...
数据结构 实验五1） 采用邻接矩阵/邻接表建立图（无向图，有向图，无向网络，有向网络）； 2） 采用深度优先/广度优先搜索方式遍历图；
修竹的博客
06-09 1万+
实验目的： 1. 掌握图的邻接矩阵和邻接表的存储结构； 2. 验证图在不同存储结构下遍历操作的实现。 3. 掌握图的实际应用 实验内容： 采用邻接矩阵/邻接表建立图（无向图，有向图，无向网络，有向网络）； 采用深度优先/广度优先搜索方式遍历图； #include <iostream> #include <stdio.h...
第十二周项目2-操作用邻接表存储的图
tongxingfeng的博客
11-30 267
/* Copyright (c)2015,烟台大学计算机与控制工程学院 All rights reserved. 文件名称：第十二周项目2-操作用邻接表存储的图 作 者：佟兴锋 完成日期：2015年11月30日 版 本 号：v1.0 问题描述:假设图G采用邻接表存储，分别设计实现以下要求的算法： 　　 （1）输出出图
数据结构之图(三)——邻接表
热门推荐
daocaoren_的博客
08-06 5万+
邻接表表示法(链式) 顶点： 按编号顺序将顶点数据存储在一维数组中。 关联同一顶点的边： 用线性链表存储。 如果有边\弧的信息，还可以在表结点中增加一项， 无向图的邻接表 例子： 特点： 邻接表不唯一 若无向图中有n个顶点、e条边，则其邻接表需要n个头结点和2e个表结点。适宜存储稀疏图。 无向图中顶点viv_ivi​的度为第i个单链表中的结点数。 有向图的邻接表 ...
（九）数据结构之邻接矩阵、邻接表存储图
温柔的博客
02-03 1620
文章目录1，邻接矩阵简述1.1，邻接矩阵适用情况2，邻接表简述2.1，邻接表适用情况3，邻接矩阵实现代码3.1，运行截图4，邻接表实现代码4.1，运行截图5，ending 1，邻接矩阵简述  邻接矩阵：采用二维数组的形式来存储图或网。 有向、无向图，有向、无向网都可以采用邻接矩阵的方式存储，下面分别分析一些需要注意的细节点： 1，有向图：有向图的邻接矩阵不根据主对角线对称 2，无向图：根据主对角线...
算法与数据结构基础8 C++实现有向图——邻接表存储
qq_44910471的博客
04-14 923
算法与数据结构基础8 C++实现有向图——邻接表存储
图——操作用邻接表存储的图
Henry's Blog
11-22 3529
/* *Copyright (c) 2015 , 烟台大学计算机学院 *All right resvered . *文件名称: 操作用邻接表存储的图.cpp *作 者: 郑兆涵 *图——操作用邻接表存储的图 */ 问题：假设图G采用邻接表存储，分别设计实现以下要求的算法： （1）输出出图G中每个顶点的出度； （2）求出图G中出度最大的一个顶点，输出该顶点编号；
项目2-操作用邻接表存储的图
q6826的博客
11-16 284
/* *2015,烟台大学计算机与控制工程学院 *All rights reserved *文件名称：graph.cpp *作者：邱暖 *完成日期：2015年11月16日 *问题描述：假设图G采用邻接表存储，分别设计实现以下要求的算法： *（1）输出出图G中每个顶点的出度； *（2）求出图G中出度最大的一个顶点，输出该顶点编号； *（3）计算图G中出度为0的顶点数； *（4）判
6-2 邻接表存储图的广度优先遍历 代码实现c语言
最新发布
04-23
以下是 C 语言实现邻接表存储图的广度优先遍历的代码示例： ```c #include #include #define MAX_VERTEX_NUM 100 // 最大顶点数 // 邻接表中表示边的结构体 typedef struct ArcNode { int adjvex; // 邻接点的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值