邻接矩阵图的应用c++

最新推荐文章于 2021-01-21 16:53:47 发布
最新推荐文章于 2021-01-21 16:53:47 发布
阅读量816 收藏 2
点赞数
分类专栏： 数据结构基本内容 文章标签： 数据结构 邻接矩阵
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guozhiyao4/article/details/52144736
版权

注：若有错误或要改善的地方请告之，谢谢，新手上路，有些函数还是很冗余的，慢慢改进。

头文件：

#define MAXSIZE 100
typedef enum
{
    NN,
    NY,
    YN,
    YY
}MGragh_type;

/*************结构体************/
/*邻接矩阵*/
typedef struct
{
    char vex[MAXSIZE]; //顶点表
    int edge[MAXSIZE][MAXSIZE];   //边表
    int vexnum,arcnum;
    int MGragh_type;
}MGragh;
/*************图的操作****************/
/*初始化图*/
MGragh *init_MGragh()
{
    MGragh *m;
    m=(MGragh*)malloc(sizeof(MGragh));
    m->arcnum=m->vexnum=0;
    printf("请输入选择的图的类型 1、无向图 2、无向网 3、有向图 4、有向网：");
    scanf("%d",&m->MGragh_type);
    memset(m->edge,0,sizeof(m->edge));
    memset(m->vex,'#',sizeof(m->vex));
    return m;
}
/*返回结点在结点表的编号*/
int return_vexno(MGragh m,char e)
{
    int i;
    for(i=0;i<m.vexnum;i++)
    {
        if(m.vex[i]==e)
        {
            return i;
        }
    }
    return -1;
}
/*返回结点的出度*/
int return_vex_out(MGragh m,char a)
{
    int an=return_vexno(m,a);
    int i,num=0;
    for(i=0;i<m.vexnum;i++)
    {
        if(m.edge[an][i]>0)
        {
            num++;
        }
    }
    return num;
}
/*判断结点是否在结点表中*/
bool if_vex_in(MGragh m,char e)
{
    int i;
    for(i=0;i<m.vexnum;i++)
    {
        if(m.vex[i]==e)
        {
            return true;
        }
    }

    return false;
}
/*判断边是否已经存在*/
bool if_arc_in(MGragh m,int xn,int yn)  //xn,yn是结点在结点表的编号
{
    if(m.edge[xn][yn]>0)
    {
        return true;
    }
    return false;
}
/*创建无向图*/
void create_MGragh_NN(MGragh *m)
{
    int V,E,i,xn,yn;
    char x,y;
    printf("创造无向图\n请输入结点数与边数：");
    scanf("%d%d",&V,&E);
    printf("请依次输入头尾结点：\n");
    for(i=0;i<E;i++)
    {
        fflush(stdin);
        scanf("%c %c",&x,&y);
        fflush(stdin);
        if(!if_vex_in(*m,x))
        {
            m->vex[m->vexnum++]=x;
        }
        if(!if_vex_in(*m,y))
        {
            m->vex[m->vexnum++]=y;
        }
        xn=return_vexno(*m,x);
        yn=return_vexno(*m,y);
        if(if_arc_in(*m,xn,yn)||if_arc_in(*m,yn,xn))
        {
            continue;
        }
        m->edge[xn][yn]=m->edge[yn][xn]=1;
        m->arcnum++;
    }
}
/*创建无向网*/
void create_MGragh_NY(MGragh *m)
{
    int V,E,i,xn,yn,c;
    char x,y;
    printf("创造无向网\n请输入结点数与边数：");
    scanf("%d%d",&V,&E);
    printf("请依次输入头尾结点与权值：\n");
    for(i=0;i<E;i++)
    {
        fflush(stdin);
        scanf("%c %c %d",&x,&y,&c);
        fflush(stdin);
        if(!if_vex_in(*m,x))
        {
            m->vex[m->vexnum++]=x;
        }
        if(!if_vex_in(*m,y))
        {
            m->vex[m->vexnum++]=y;
        }
        xn=return_vexno(*m,x);
        yn=return_vexno(*m,y);
        if(if_arc_in(*m,xn,yn)||if_arc_in(*m,yn,xn))
        {
            continue;
        }
        m->edge[xn][yn]=m->edge[yn][xn]=c;
        m->arcnum++;
    }
}
/*创建有向图*/
void create_MGragh_YN(MGragh *m)
{
    int V,E,i,xn,yn;
    char x,y;
    printf("创造有向图\n请输入结点数与边数：");
    scanf("%d%d",&V,&E);
    printf("请依次输入头尾结点：\n");
    for(i=0;i<E;i++)
    {
        fflush(stdin);
        scanf("%c %c",&x,&y);
        fflush(stdin);
        if(!if_vex_in(*m,x))
        {
            m->vex[m->vexnum++]=x;
        }
        if(!if_vex_in(*m,y))
        {
            m->vex[m->vexnum++]=y;
        }
        xn=return_vexno(*m,x);
        yn=return_vexno(*m,y);
        if(if_arc_in(*m,xn,yn))
        {
            continue;
        }
        m->edge[xn][yn]=1;
        m->arcnum++;
    }
}
/*创建有向网*/
void create_MGragh_YY(MGragh *m)
{
    int V,E,i,xn,yn,c;
    char x,y;
    printf("创造有向网\n请输入结点数与边数：");
    scanf("%d%d",&V,&E);
    printf("请依次输入头尾结点与权值：\n");
    for(i=0;i<E;i++)
    {
        fflush(stdin);
        scanf("%c %c %d",&x,&y,&c);
        fflush(stdin);
        if(!if_vex_in(*m,x))
        {
            m->vex[m->vexnum++]=x;
        }
        if(!if_vex_in(*m,y))
        {
            m->vex[m->vexnum++]=y;
        }
        xn=return_vexno(*m,x);
        yn=return_vexno(*m,y);
        if(if_arc_in(*m,xn,yn))
        {
            continue;
        }
        m->edge[xn][yn]=c;
        m->arcnum++;
    }
}
/*创造图*/
void create_MGragh(MGragh *m)
{
    switch(m->MGragh_type)
    {
        case 1:create_MGragh_NN(m);break;
        case 2:create_MGragh_NY(m);break;
        case 3:create_MGragh_YN(m);break;
        case 4:create_MGragh_YY(m);break;
    }
}
/*输出图*/
void print_MGragh(MGragh m)
{
    int i,j;
    printf("该图的邻接矩阵为：\n");
    for(i=0;i<m.vexnum;i++)
    {
        for(j=0;j<m.vexnum;j++)
        {
            printf("|%d|",m.edge[i][j]);
        }
        printf("\n");
    }
    printf("该图的顶点表为：");
    for(i=0;i<m.vexnum;i++)
    {
        printf("%c",m.vex[i]);
    }
    printf("\n");
    printf("该图的顶点数为%d，边数为%d\n",m.vexnum,m.arcnum);
}
图的应用： 

#include<stdlib.h>
#include<stdio.h>
#include<string>
#include<cstring>
#include<math.h>
#include<algorithm>
#include<ctype.h>
#include"../../头文件/image_seq.h"
using namespace std;

int tohead[MAXSIZE];    //祖先数组，tohead[x]=y，编号为y的字符是编号为x的字符的祖先
bool visited[MAXSIZE][MAXSIZE]; //visited[][]为边访问标记
bool visited_node[MAXSIZE]; //为结点的标记
/******************公共函数********************/
/*初始化visited_node[]*/
void init_visited_node(MGragh m)
{
    int i;
    for(i=0;i<m.vexnum;i++)
    {
        visited_node[i]=false;
    }
}
/*判断图是否还有未被访问的与其连接的下一结点*/
/*若存在，则返回权值最小权值的头尾结点的编号(xn,yn)与权值min_*/
bool if_exist_next_node(MGragh m,int &xn,int &yn,int &min_)
{
    int i,j;
    min_=INT_MAX;
    for(i=0;i<m.vexnum;i++)
    {
        for(j=0;j<m.vexnum;j++)
        {
            if(m.edge[i][j]>0&&m.edge[i][j]<min_&&!visited_node[j]&&visited_node[i])    //j要未访问过，i要访问过
            {
                min_=m.edge[i][j];
                xn=i;
                yn=j;
            }
        }
    }
    if(min_!=INT_MAX)
    {
        return true;
    }
    else
    {
        xn=yn=min_=0;
        return false;
    }
}
/*初始化visited[][]*/
void init_visited()
{
    memset(visited,false,sizeof(visited));  //false为未访问
}
/*寻找权值最小且未访问的结点的编号*/
void min_edge(MGragh m,int &xn,int &yn) //需预先初始化visited[][]
{
    int i,j,min_=INT_MAX;
    for(i=0;i<m.vexnum;i++)
    {
        for(j=0;j<m.vexnum;j++)
        {
            if(m.edge[i][j]<min_&&!visited[i][j]&&m.edge[i][j]>0)
            {
                xn=i;
                yn=j;
                min_=m.edge[i][j];
            }
        }
    }
    visited[xn][yn]=true;
}
/*输出访问标记边*/
void print_visited(MGragh m)
{
    int i,j;
    printf("该图的访问标记为：\n");
    for(i=0;i<m.vexnum;i++)
    {
        for(j=0;j<m.vexnum;j++)
        {
            printf("|%d|",visited[i][j]);
        }
        printf("\n");
    }
}
/******************并查集*******************/
/*初始化tohead[]*/
/*初始化设置各个结点的祖先为自己*/
void init_tohead()
{
    int i;
    for(i=0;i<MAXSIZE;i++)
    {
        tohead[i]=i;
    }
}
/*找出结点的祖先*/
int find_(int x) //x为结点的编号
{
    if(tohead[x]==x)
    {
        return x;
    }
    else
    {
        return tohead[x]=find_(tohead[x]);
    }
}
/*将两结点的祖先合并*/
void union_(int x,int y)
{
    x=find_(x);
    y=find_(y);
    tohead[x]=y;
}
/********************最小生成树（MST）**********************/
/*Kruskal*/
/*选边*/
int Kruskal(MGragh m)   //使用并查集
{
    init_tohead();
    init_visited(); //为min_edge()设定的
    int xn,yn,i,vil=0;
    for(i=0;i<m.arcnum;i++)
    {
        min_edge(m,xn,yn);
        if(find_(xn)!=find_(yn))
        {
            vil+=m.edge[xn][yn];
            union_(xn,yn);
        }
    }
    printf("(kruskal)该图的最小生成树的权值为%d\n",vil);
    print_visited(m);
    return vil;
}
/*prim*/
/*选点*/
int prim(MGragh m)  //不使用并查集
{
    init_visited_node(m);
    int vexnum=1,headnum=0,i,j,xn,yn,vilue,num=0,min_=INT_MAX;
    for(headnum=0;headnum<m.vexnum;headnum++)
    {
            visited_node[headnum]=true;
            while(vexnum<m.vexnum)
            {
                if(!if_exist_next_node(m,xn,yn,vilue))
                {
                    break;
                }
                num+=vilue;
                visited_node[yn]=true;
                vexnum++;
            }
            if(vexnum>=m.vexnum)
            {
                min_=min(min_,num);
            }
            num=0;
            vexnum=1;
            init_visited_node(m);
    }
    printf("(prim)该图的最小生成树权值为%d\n",min_);
    return min_;
}
/***********************最短路径***************************/
/*dijkstra*/
/*单源最短路径*/
void dijkstra(MGragh m,char x)  //x为头结点
{
    printf("(dijkstra)该图从%c到其余各点的最短路径为:\n",x);
    int xn=return_vexno(m,x);
    int i,j;
    for(i=0;i<m.vexnum;i++)
    {
        for(j=0;j<m.vexnum;j++)
        {
            if(m.edge[xn][j]>(m.edge[xn][i]+m.edge[i][j])&&m.edge[xn][j]>0&&m.edge[xn][i]>0&&m.edge[i][j]>0)
            {
                m.edge[xn][j]=m.edge[xn][i]+m.edge[i][j];
            }
        }
    }
    print_MGragh(m);
}
/*floryd*/
/*多源最短路径*/
void floryd(MGragh m) //不改变图
{
    printf("（floryd）该图的最短路径为：\n");
    int i,j,k;  //k为插入的结点
    for(k=0;k<m.vexnum;k++)
    {
        for(i=0;i<m.vexnum;i++)
        {
            for(j=0;j<m.vexnum;j++)
            {
                if(m.edge[i][j]>(m.edge[i][k]+m.edge[k][j])&&m.edge[i][j]>0&&m.edge[i][k]>0&&m.edge[k][j]>0)
                {
                    m.edge[i][j]=m.edge[i][k]+m.edge[k][j];
                }
            }
        }
    }
    print_MGragh(m);
}
int main()
{
    MGragh *m;
    m=init_MGragh();
    create_MGragh(m);
    print_MGragh(*m);
    prim(*m);
    return 0;
}
/*
a c 3
a d 8
a b 5
c d 10
d a 7
d b 20
a c
a d
a b
c d
d a
d b
*/



半路出道程序猿
关注
专栏目录
图的实现：邻接矩阵
07-31
使用邻接矩阵实现图结构，无论是有向图、无向图、带权图还是无权图，都可以指定。
C++实现图（邻接矩阵）
weixin_34252686的博客
02-22 973
1 #include<iostream> 2 3 #define Max 20 4 using namespace std; 5 6 class Vertex 7 { 8 public: 9 Vertex(char lab) {Label=lab;} 10 private: 11 char Label; 12 }; 13...
图的建立与遍历c++实现（邻接矩阵存储）
10-14
这是一个关于图的建立与遍历的问题，用的是c++实现，邻接矩阵作为存储
邻接矩阵的理解与应用
飘羽的博客
11-09 5363
邻接矩阵（Adjacency Matrix）是表示顶点之间相邻关系的矩阵。设G=(V,E)是一个图，其中V={v1,v2,…,vn}[1]。G的邻接矩阵是一个具有下列性质的n阶方阵： （1）对无向图而言，邻接矩阵一定是对称的，而且主对角线一定为零（在此仅讨论无向简单图），副对角线不一定为0，有向图则不一定如此。 （2）在无向图中，任一顶点i的度为第i列（或第i行）所有非零元素的个数，在有向图中顶点i的出度为第i行所有非零元素的个数，而入度为第i列所有非零元素的个数。 （3）用邻接矩阵法表示图共需...
邻接矩阵的应用
weixin_30361641的博客
07-10 1315
在近期的学习中，了解到了关于邻接矩阵的一些有用的应用， 再次做一些记录。 邻接矩阵的记录 邻接矩阵分为两种， 一种存的是边权（记作D）， 即 　　 还有一种是没有边权的， 记录的是连通关系（记作A）， 即 　　 连通性邻接矩阵在矩阵的幂定义下的意义 　　对于表示连通关系的矩阵A在矩阵的幂定义下有一下的意义： 传递闭包（floyd） 　　对于矩阵A（连通性邻接矩阵），对其作如下运算...
c++ 实现邻接矩阵
qq_45682014的博客
01-21 1009
c++ 实现邻接矩阵 代码如下 #include <iostream> #include<vector> using namespace std; class Graph { public: int vexs[100]; int edges[100][100]; int vex; int edge; Graph() { for (int i = 0; i < 100; i++) { vexs[i] = 0; } for (int i = 0;
图之邻接矩阵详解（C语言版）.rar
04-24
本文将详细讲解一种常见的图数据结构表示方法——邻接矩阵，并通过C语言实现相关操作。邻接矩阵是图理论中的重要概念，用于描述图中节点之间的连接关系。 首先，我们需要理解什么是图。在计算机科学中，图是由顶点...
ch7.rar_创建邻接矩阵_邻接矩阵_邻接矩阵c＋＋_邻接表
09-21
总之，理解和掌握邻接矩阵与邻接表是学习图论和算法的重要部分，它们在解决许多实际问题中都有广泛应用，比如网络路由、社交网络分析、机器学习中的图模型等。通过实践和不断练习，你可以更好地运用这些数据结构来...
C++实现图的邻接矩阵表示
08-19
C++实现图的邻接矩阵表示 在计算机科学和信息技术领域中，图理论是一个非常重要的概念，广泛应用于社会网络、交通网络、计算机网络等领域。图的表示方式有多种，邻接矩阵是一种常用的图表示方法。在C++中实现图的...
有向图邻接矩阵c++运算操作
07-19
有向图邻接矩阵c++运算操作 基本操作 邻接矩阵 c++实现
图的邻接矩阵和邻接表存储结构（C++）
06-07
本文将深入探讨如何在C++中实现图的两种主要存储结构：邻接矩阵和邻接表。 **邻接矩阵** 邻接矩阵是一种二维数组，其中的元素表示图中两个顶点之间是否存在边。如果存在边，矩阵中的对应位置通常用1表示；若不存在...
最小生成树.Prim-邻接矩阵_邻接矩阵_C++_Windows编程_
10-04
在这个案例中，C++被用来实现Prim算法，通过邻接矩阵来表示图，并进行遍历和计算最小生成树。 Windows编程通常是指在Microsoft Windows操作系统环境下进行的软件开发。尽管Prim算法本身与操作系统无关，但在Windows...
c++实现邻接矩阵
orange_monkey的博客
11-26 2762
#include<iostream> using namespace std; const int MAX = 10; //最大顶点数 //typedef char vertex_type; //顶点类型 //typedef int edge_weight_type; //边上权值类型 template<class vertex_type, class edge_weight_type> class Graph { private: int vertex_num; //顶点数
图结构（四）- 邻接矩阵有向图
AnndyR的专栏
01-27 1695
 一、邻接矩阵有向图的介绍 邻接矩阵有向图是指通过邻接矩阵表示的有向图。 上面的图G2包含了"A,B,C,D,E,F,G"共7个顶点，而且包含了",,,,,,,,"共9条边。 上图右边的矩阵是G2在内存中的邻接矩阵示意图。A[i][j]=1表示第i个顶点到第j个顶点是一条边，A[i][j]=0则表示不是一条边；而A[i][j]表示的是第i行第j列的值；例如，A[1,2]=1，表示第
邻接矩阵-图中应用
futurerock的专栏
05-06 5430
定义邻接矩阵（Adjacency Matrix）：是表示顶点之间相邻关系的矩阵。设G=(V,E)是一个图，其中V={v1,v2,…,vn}。G的邻接矩阵是一个具有下列性质的n阶方阵： 特点无向图的邻接矩阵一定是对称的，而有向图的邻接矩阵不一定对称。因此，用邻接矩阵来表示一个具有n个顶点的有向图时需要n2个单元来存储邻接矩阵；对有n个顶点的无向图则只存入上（下）三角阵中剔除了左上右下
图的邻接矩阵实现（c++）
qq_29131907的博客
04-08 430
/*#include<iostream> using namespace std; #define Max 100 typedef struct Enode *ptroEnode; struct Enode { int v1, v2; int weight; }; typedef ptroEnode Edege; typedef struct Adjnode *ptrToAdjVN...
图（邻接矩阵实现）（C++实现）
qq_39559641的博客
04-07 5174
一、实验要求 设计图（网）的邻接矩阵，编写算法实现下列问题的求解。 1．打印出图（网）的两种遍历序。 实验测试数据基本要求： 第一组数据： udg8.grp 第二组数据： udg115.grp 第三组数据： dg6.grp 2．求给定图中的边（或弧）的数目。 实验测试数据基本要求： 第一组数据： udg8.grp 第二组数据： udg115.grp 3．...
邻接表存储的图的基本操作c++
guozhiyao4的博客
08-06 2123
注：若有错误或需要改进的地方，或有需要补充的内容请告之，新手上路，谢谢。有些函数还是比较冗余的，慢慢改进。 头文件： /*使用栈和队列要用指针*/ /************结构体************/ /*队列*/ typedef struct qnode { void* data; struct qnode *next; }qnode; typedef stru
C++实现：图的邻接矩阵及其应用
本文将深入探讨图的邻接矩阵这一数据结构的实现及其在实际问题中的应用。图的邻接矩阵是表示图的一种有效方法，尤其适用于稠密图，即节点间连接较多的情况。该矩阵是一个二维数组，其中的元素表示图中节点之间的边...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值