操作用邻接表存储的图1

最新推荐文章于 2020-08-27 11:25:19 发布
最新推荐文章于 2020-08-27 11:25:19 发布
阅读量563 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BiBiBiu/article/details/49867761
版权

问题描述：

/*    
01.  
02.  
03.*Copyright(c) 2015,烟台大学计算机学院    
04.*All rights reserved.    
05.*文件名称: 111.cpp    
06.*作    者: 田**    
07.*完成日期：2015年11月16日    
08.*版 本 号：V1.0    
09.*    
10.*问题描述：操作用邻接表存储的图
11.*程序输出：    
*/   

头文件：
#ifndef GRAPH_H_INCLUDED
#define GRAPH_H_INCLUDED

#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 <stdio.h>
#include <malloc.h>
#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");
    }
}


主函数：

#include <stdio.h>
#include <malloc.h>
#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");
    }
}


运行结果：




BiBiBiu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以邻接表的形式建立和存储图
07-03
以邻接表的形式建立和存储图。将每次新输入的节点插在表尾端，然后输出邻接表。并用深度优先搜索法进行图的遍历。
邻接表存储的图
08-25
1、 定义邻接表存储的图类。 2、 实验验证如下算法的正确性、各种功能及指标： 1）创建一个邻接表存储的图； 2）返回图中指定边的权值； 3）返回图中某顶点的第一个邻接顶点； 4）返回图中某顶点关于另一个顶点的下...
操作用邻接表存储的图
wangjiyuan123的博客
11-23 390
问题及代码： 问题描述: 实现图遍历算法，分别输出如下图结构的深度优先(DFS)遍历序列和广度优先遍历(BFS)序列。 输入描述：若干测试数据。 程序输出：DFS,BFS的遍历序列。 int OutDegree(ALGraph *G,int v) { ArcNode *p; int n=0; p=G->adjlist[v].firstarc;
图的存储（邻接表）
weixin_44460602的博客
08-27 400
图一般有两种存储方式 邻接矩阵：开一个二维数组，g[i][j] 表示点 i 和点 j 之间边的权值 邻接表：邻接表第一种方法利用数组模拟链表 第二种方法利用vector存储 下面详细说明邻接表的两种存储方法，全部以下图二叉树为模板 数组模拟链表：开三个一维数组和一个初始值为0的变量 e[i] ne[j] h[k] idx=0; 具体关系：若顶点为 k 则与其相连的另一顶点为 e[h[k]],那么想要以e[h[k]]为顶点继续向下找相邻的顶点，需判断ne[h[k]]是否为-1 若为-1 则不存在相邻点，若存
第十二周 项目二--操作用邻接表存储的图
编写博客，学习交流
11-17 463
main.cpp/* Copyright (c)2016,烟台大学计算机与控制工程学院 All rights reserved. 文件名称：tu.pp 作 者： 周国亮 完成日期：2016年11月17日 版 本 号：v1.0
头歌数据结构图的邻接表存储及遍历操作
05-26
根据给定文件的信息，我们可以总结出以下关于图的邻接表存储及遍历操作的关键知识点： ### 一、邻接表的基本概念 邻接表是一种用于表示图的存储结构，适用于稀疏图（即边的数量远小于顶点数量的平方）。它通过一...
数据结构学习--图的邻接矩阵和邻接表存储
06-25
总的来说，理解和熟练掌握图的邻接矩阵和邻接表存储方式，对于解决实际问题，如网络路由、社交网络分析、图形算法等具有重要意义。通过这样的实验，可以加深对这两种存储方式的理解，提高编程能力。
C++实现图的邻接表存储和广度优先遍历实例分析
09-03
本文主要讲解了如何使用邻接表存储图以及如何实现广度优先遍历（BFS）。邻接表是一种节省空间且适合处理稀疏图（边的数量远小于顶点数量的平方）的数据结构。 首先，我们来理解邻接表的概念。在邻接表中，每个顶点...
java实现图的邻接表存储结构的两种方式及实例应用详解
08-25
Java 实现图的邻接表存储结构的两种方式及实例应用详解 本文主要介绍了 Java 实现图的邻接表存储结构的两种方式及实例应用详解。图的邻接表是一种常用的图存储结构，它将图的顶点和边信息存储在一个数组中，使得图...
图结构的实现并用邻接表储存
Wo_1820的博客
11-21 271
图结构的实现并用邻接表储存 你好！ 这是我第一次使用 Markdown编辑器 ！我很激动 图类 // 图的基类 class Edge;{ //边类 public : int from, to, weight; //from是起点，to是终点，weight是权重 ...
数据结构实践——操作用邻接表存储的图
ytdxtzj的博客
11-23 429
/* * Copyright (c) 2015, 烟台大学计算机与控制工程学院 * All rights reserved. * 文件名称： main.cpp,graph.h,graph.cpp * 作者：唐子健* 完成日期：2015年11月23日 * 版本号：codeblocks * * 问题描述: 输出出图G中每个顶点的出度 * 输入描述： 无 * 程序输出： 见运行结果
以邻接表为存储结构的---图的算法实现
bingbing200x的专栏
09-24 1548
 using System;using System.Collections.Generic;using System.Collections.Specialized;namespace HBDiscover{    public class AdjacencyList    {        List> items; //图的顶点集合         
图的邻接表存储以及相关操作 C语言
菜鸟的逆袭
09-05 6248
/****************************************/ #include #include #include /****************************************/ #define MaxVex 255
图的基本操作
Steve_Abelieve
04-12 414
我们采用邻接矩阵的方式来存储图： 基础练习： 1.图的深度优先遍历 2.图的广度优先遍历#ifndef CMAP_H #define CMAP_H#include<vector> using namespace std; #include"Node.h"class CMap { public: CMap(int capacity); ~CMap(); bool addNo
图的邻接表存储方式的建立
weixin_30268921的博客
05-18 135
图的邻接表存储方式，主要由表节点与头结点组成。 头结点中主要包含两个域： 1）存放顶点信息 2）存放与顶点相连的第一个表节点的指针 表节点中主要包含两个域： 1）存放相连的节点的序号 2）指向下一个节点的指针 #define MAXNUM 100 //表节点 typede...
第十一项目二 操作用邻接表存储的图
Hdj1597357的博客
12-13 369
#include #include #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=
OJ 邻接表的相关操作
Eli_Code
05-31 2972
邻接表的相关操作 时间限制: 1 Sec 内存限制: 128 MB 题目描述： 输入一个图，用邻接表存储，并实现一些操作。 拷贝下面的代码，按要求完成其中的FirstAdjVex，NextAdjVex，sort和CreateUDG操作，其他地方不得改动。 //图的邻接表存储表示 #include <iostream> #include <iomanip> using namespace std; #define MVNum 100 //最大顶点数 #defi
第12周-项目二-操作用邻接表存储的图
luguoca的博客
11-16 383
问题及代码： 假设图G采用邻接表存储，分别设计实现以下要求的算法：  　　（1）输出出图G中每个顶点的出度；  　　（2）求出图G中出度最大的一个顶点，输出该顶点编号；  　　（3）计算图G中出度为0的顶点数；  　　（4）判断图G中是否存在边i,j>。  　　利用下图作为测试用图，输出结果。 　　  /* *Copyright(c)2015,烟台大学计算机与控制
图的邻接表存储及遍历操作
最新发布
06-03
邻接表是一种常用的图的存储结构，它通过链表来表示每个顶点的邻接点集合。邻接表的具体实现可以使用数组加链表的方式，也可以使用纯链表的方式。 邻接表存储结构的优点是可以很方便地遍历某个顶点的邻接点，而且可以节省空间。但是，对于需要查找两个顶点之间是否有边的操作，邻接表的效率就不如邻接矩阵了。 下面是邻接表的存储结构定义： ```c // 邻接表的存储结构定义 #define MAX_VERTEX_NUM 100 // 最大顶点数 typedef struct ArcNode { // 边结点 int adjvex; // 邻接点在顶点数组中的下标 struct ArcNode *next; // 指向下一个边结点的指针 // 也可以在这里存储边的权值等信息 } ArcNode; typedef struct VNode { // 顶点结点 char data; // 顶点的数据 ArcNode *firstarc; // 指向第一个边结点的指针 } VNode, AdjList[MAX_VERTEX_NUM]; typedef struct { // 邻接表 AdjList vertices; // 顶点数组 int vexnum, arcnum; // 顶点数和边数 } ALGraph; ``` 邻接表的遍历可以使用深度优先搜索（DFS）或广度优先搜索（BFS）算法。下面是DFS的遍历代码： ```c // 邻接表的深度优先搜索遍历 void DFS(ALGraph *G, int v, bool visited[]) { visited[v] = true; printf("%c ", G->vertices[v].data); // 访问顶点v ArcNode *p = G->vertices[v].firstarc; while (p != NULL) { // 遍历v的所有邻接点 int w = p->adjvex; if (!visited[w]) { DFS(G, w, visited); } p = p->next; } } ``` BFS的遍历代码如下： ```c // 邻接表的宽度优先搜索遍历 void BFS(ALGraph *G, int v, bool visited[]) { visited[v] = true; printf("%c ", G->vertices[v].data); // 访问顶点v queue<int> Q; // 使用队列存储待访问的顶点 Q.push(v); while (!Q.empty()) { int u = Q.front(); Q.pop(); ArcNode *p = G->vertices[u].firstarc; while (p != NULL) { // 遍历u的所有邻接点 int w = p->adjvex; if (!visited[w]) { visited[w] = true; printf("%c ", G->vertices[w].data); // 访问顶点w Q.push(w); } p = p->next; } } } ``` 以上就是邻接表的存储和遍历操作。需要注意的是，邻接表的实现也可以使用其他数据结构，这里给出的只是一种常见的方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值