图的基本操作

最新推荐文章于 2021-07-14 12:44:08 发布
最新推荐文章于 2021-07-14 12:44:08 发布
阅读量4.7k 收藏 12
点赞数
分类专栏： 数据结构（课程作业） 编程语言 拓扑排序== ==最小生成树== 最短路~~

16学年—17学年第 1 学期 数据结构实验任务书

专业名称：              实验学时：    2    

课程名称：数据结构      任课教师：  翟海霞     

实验题目： 图的基本操作实现               

实验环境：   Visual C++ 6.0                   　

实验目的：掌握图的邻接矩阵和邻接表两个存储结构及表示。

          掌握图的DFS和BFS两种遍历算法。

          理解并掌握下述完整算法的基本思想以及算法实现方法：最小生成树算法、最短路径算法、拓扑排序算法及关键路径算法。

实验内容：1. 创建一个无向图，并分别对其进行DFS和BFS。

          2. 实现最短路径、最小生成树、拓扑排序三种算法。

#include<cstdio>    
#include<malloc.h>    
#include<cstdlib>    
#include<iostream>    
#include<algorithm>    
#include<cstring>    
#define OK 1    
#define ERROR 0    
#define OVERFLOW -2    
#define MaxInt 32767    
#define MVNum 100    
using namespace std;    
typedef int Status;    
bool visited[MVNum];        
typedef struct    
{    
    int vexs[MVNum];//顶点表     
    int arcs[MVNum][MVNum];//邻接矩阵     
    int vexnum,arcnum; //图的当前点数和边数     
}AMGraph;    
Status CreateUDN(AMGraph &G)//用邻接矩阵建立无向网     
{    
    int i,j,k,w;    
    int v1,v2;    
    printf("请输入总点数和总边数\n");    
    cin>>G.vexnum>>G.arcnum;//输入总点数，总边数     
    for(i=0;i<G.vexnum;i++)    
    {    
         G.vexs[i]=i;    
    }    
    for(i=0;i<G.vexnum;i++)//初始化邻接矩阵     
    {    
        for(j=0;j<G.vexnum;j++)    
        {    
            G.arcs[i][j]=MaxInt;  
            if(i==j)  
                G.arcs[i][j]=0;  
        }    
    }    
    printf("请输入边的信息以及边的权值(顶点是0~n-1)\n");    
    for(k=0;k<G.arcnum;++k)    
    {    
        cin>>v1>>v2>>w;    
        G.arcs[v1][v2]=w;    
        G.arcs[v2][v1]=w;    
    }    
    return OK;    
}    
Status CreateDirUDN(AMGraph &G)//用邻接矩阵建立有向网     
{    
    int i,j,k,w;    
    int v1,v2;    
    printf("请输入顶点数和边数\n");    
    cin>>G.vexnum>>G.arcnum;//输入总点数，总边数     
    for(i=0;i<G.vexnum;i++)    
    {    
        G.vexs[i]=i;    
    }    
    for(i=0;i<G.vexnum;i++)//初始化邻接矩阵     
    {    
        for(j=0;j<G.vexnum;j++)    
        {    
            G.arcs[i][j]=MaxInt;  
            if(i==j)  
               G.arcs[i][j]=0;    
        }    
    }    
    printf("请输入边的信息以及边的权值(顶点的范围为0~n-1)\n");    
    for(k=0;k<G.arcnum;k++)    
    {    
        cin>>v1>>v2>>w;    
        G.arcs[v1][v2]=w;    
    }    
    return OK;    
}    
typedef struct ArcNode//边结点     
{    
    int adjvex;//该边所指向的顶点的位置     
    struct ArcNode * nextarc;//指向下一条边的指针     
    //OtherInfo info;//和边相关的信息     
}ArcNode;    
typedef struct VNode//顶点信息     
{    
    int data;    
    ArcNode *firstarc;//指向第一条依附该顶点的边的指针     
}VNode,AdjList[MVNum];    
typedef struct    
{    
    AdjList vertices;    
    int visited[MVNum];    
    int vexnum,arcnum;//图的当前节点数和边数     
}ALGraph;    
Status CreateUDG(ALGraph &G)//邻接表无向网     
{    
    ArcNode *p1,*p2;    
    int v1,v2,i,j,k;    
    printf("请输入总点数和总边数\n");    
    cin>>G.vexnum>>G.arcnum;    
    for(i=0;i<G.vexnum;++i)    
    {    
        G.vertices[i].data=i;//输入顶点值     
        G.vertices[i].firstarc=NULL;//初始化表头节点的指针域为空     
    }    
    printf("依次输入边的信息（顶点范围为0~n-1）\n");    
    for(k=0;k<G.arcnum;++k)    
    {    
        cin>>i>>j;    
        p1=(ArcNode *)malloc(sizeof(ArcNode));    
        p1->adjvex=j;    
        p1->nextarc=G.vertices[i].firstarc;    
        G.vertices[i].firstarc=p1;//将新结点*P1插入顶点Vi的头部     
        p2=(ArcNode *)malloc(sizeof(ArcNode));    
        p2->adjvex=i;    
        p2->nextarc=G.vertices[j].firstarc;    
        G.vertices[j].firstarc=p2;    
    }    
    return OK;    
}        
Status CreateDirUDG(ALGraph &G)//邻接表有向网     
{    
    ArcNode *p1,*p2;    
    int v1,v2,i,j,k;    
    printf("请输入总点数和总边数\n");    
    cin>>G.vexnum>>G.arcnum;    
    for(i=0;i<G.vexnum;++i)    
    {    
        G.vertices[i].data=i;//输入顶点值     
        G.vertices[i].firstarc=NULL;//初始化表头节点的指针域为空  
    }    
    printf("依次输入边的信息（顶点范围为0~n-1）\n");     
    for(k=0;k<G.arcnum;++k)    
    {    
        cin>>i>>j;    
        p1=(ArcNode *)malloc(sizeof(ArcNode));    
        p1->adjvex=j;    
        p1->nextarc=G.vertices[i].firstarc;    
        G.vertices[i].firstarc=p1;//将新结点*P1插入顶点Vi的头部       
    }    
    return OK;    
}    
void DFS_AL(ALGraph G,int v)    
{//图G为邻接表类型，从第V个顶点出发深度优先搜索遍历图G     
    ArcNode *p;    
    int w;    
    cout<<v;//访问第v个顶点     
    visited[v]=true;//标记该顶点已访问过     
    p=G.vertices[v].firstarc;//p指向V的边链表的第一个顶点     
    while(p!=NULL)//边结点非空     
    {    
        w=p->adjvex;//w是V的邻接点     
        if(!visited[w])//如果W未访问，则递归调用DFS__AL     
        DFS_AL(G,w);    
        p=p->nextarc;//p指向下一个边结点     
    }    
}    
typedef struct//队列的顺序储存     
{    
    int *base;    
    int front;    
    int rear;    
}SqQueue;    
Status InitQueue(SqQueue &Q)    
{//构造一个空的循环队列     
	Q.base=(int*)malloc(sizeof(int)*MVNum) ;
    if(!Q.base)    
    exit(OVERFLOW);    
    Q.front=Q.rear=0;    
    return OK;    
}    
Status EnQueue(SqQueue &Q,int v)    
{//插入元素v为Q的新队尾元素     
    if((Q.rear+1)%MVNum==Q.front)    
        return ERROR;    
    Q.base[Q.rear]=v;//新元素插入队尾     
    Q.rear=(Q.rear+1)%MVNum;//队尾指针加一     
    return OK;    
}    
Status DeQueue(SqQueue &Q,int &v)    
{//删除Q的队头元素，用V返回其值     
    if(Q.front==Q.rear)    
        return ERROR;    
    v=Q.base[Q.front];//保存队头元素     
    Q.front=(Q.front+1)%MVNum;//队头指针加一     
    return OK;    
}    
Status QueueEmpty(SqQueue &Q)//判断队列是否为空     
{    
    if(Q.front==Q.rear)    
      return 1;    
    return 0;    
}    
void Visit(ALGraph &G,int i)    
{     
	printf(" %d",G.vertices[i].data)  ; 
    G.visited[i]=1;        //将访问标志置为1    
}    
void BFS_AL(ALGraph G,int v)    
{//按广度优先非递归遍历连通图G    
    SqQueue Q;    
    ArcNode *w;    
    int u;     
    cout<<v;//访问第v个顶点      
    visited[v]=true;//标记v已经访问过     
    InitQueue(Q);//初始化队列Q     
    EnQueue(Q,v);//V进队     
    while(!QueueEmpty(Q))//队列非空     
    {    
        DeQueue(Q,u);//队头元素出队并置为u     
        for(w=G.vertices[u].firstarc;w;w=w->nextarc)    
        {//依次检查u的所有邻接点w     
            if(!G.visited[w->adjvex] )    
            {    
                Visit(G,w->adjvex);    
                EnQueue(Q,w->adjvex);    
            }    
        }    
    }   
	printf("\n"); 
}    
 struct  node    
{    
    int adjvex;//最小边在U的那个顶点     
    int lowcost;//最小边上的权值     
}closedge[MVNum];    
void MiniSpanTree_Prim(AMGraph G,int k)     
{//无向网G以邻接矩阵形式储存，从顶点u出发构造G的最小生成树T,输出T的各条边     
    //k=LocateVex(G,u);//k为顶点u的下标    
    int i,j,u0,v0,minn;     
    for(j=0;j<G.vexnum;j++)//对V-U的每个顶点vj,初始化closedge[j]     
          if(j!=k)    
          {    
              closedge[j].adjvex=k;    
              closedge[j].lowcost=G.arcs[k][j];    
          }    
    closedge[k].lowcost=0;//初始，U={u};    
    for(i=1;i<G.vexnum;++i)    
    {//选择其余n-1个顶点，生成n-1条边     
        minn=MaxInt;    
        for(j=0;j<G.vexnum;j++)    
        {    
            if(closedge[j].lowcost>0)
            {
	            if(closedge[j].lowcost<minn)    
	            {    
	                 k=j;    
	                 minn=closedge[j].lowcost;    
	            }  
			}       
        }    
        u0=closedge[k].adjvex;//u0为最小边的一个顶点，u0属于U     
        v0=G.vexs[k];//v0为最小边的另一个顶点，v0属于V-U     
        cout<<u0<<v0;//输出当前最小边
		printf("\n");     
        closedge[k].lowcost=0;//第K个顶点并入U集     
        for(j=0;j<G.vexnum;++j)    
        {  
            if(G.arcs[k][j]<closedge[j].lowcost)//新顶点并入U集后重新选择最小边     
            {    
                closedge[j].adjvex=G.vexs[k];    
                closedge[j].lowcost=G.arcs[k][j];    
             }   
        }         
    }    
}      
void ShortestPath_DIJ(AMGraph G,int v0)//最短路径     
{    
    int n,v,i,j,minn,w;   
    bool S[1100];    
    int Path[1100],D[1100];    
    n=G.vexnum;    
    for(v=0;v<n;++v)//顶点初始化     
    {    
        S[v]=false;    
        D[v]=G.arcs[v0][v];    
        if(D[v]<MaxInt)    
           Path[v]=v0;    
        else    
           Path[v]=-1;    
    }    
    S[v0]=true;    
    D[v0]=0;    
    //求v0到某个顶点v的最短路径 ，将v加到s集     
    for(i=1;i<n;++i)    
    {    
        minn=MaxInt;    
        for(w=0;w<n;++w)    
           if(!S[w]&&D[w]<minn)    
           {    
               v=w;    
               minn=D[w];    
           }    
        S[v]=true;    
        for(w=0;w<n;++w)    
           if(!S[w]&&(D[v]+G.arcs[v][w]<D[w]))    
           {    
               D[w]=D[v]+G.arcs[v][w];    
               Path[w]=v;    
           }    
    }   
    for(i=1;i<n;++i)  
      printf("%d %d %d\n",G.vexs[0],G.vexs[i],D[i]);    
}    
typedef struct  
{  
    int *base;  
    int *top;  
    int stacksize;  
}SqStack;  
Status InitStack(SqStack &S)//初始化   
{  
    S.base=(int*)malloc(sizeof(int)*MVNum);  
    if(!S.base)  
    exit(OVERFLOW);  
    S.top=S.base;  
    S.stacksize=MVNum;  
    return OK;  
}  
Status Push(SqStack &S,int e)//入栈   
{  
    if(S.top-S.base==S.stacksize)  
    return ERROR;//栈满   
    *S.top++=e;//元素e压入栈顶，栈顶指针加1;   
    return OK;  
 }   
Status Pop(SqStack &S,int &e)//出栈   
{  
    if(S.top==S.base)//栈空   
    return ERROR;  
    e=*--S.top;//栈顶指针减一，将栈顶元素赋给e;   
    return OK;  
}  
Status StackEmpty(SqStack S)//判断栈空     
{    
    if(S.top==S.base)
	     return 1;
    return 0;    
       
}  
void Findindegree(ALGraph G,int indegree[]) //求入度 
{
	int i;
	for(i=0;i<G.vexnum;i++)
	{
		indegree[i]=0;
	}
	for(i=0;i<G.vexnum;i++)
	{
		while(G.vertices[i].firstarc)
		{
			indegree[G.vertices[i].firstarc->adjvex]++;
			G.vertices[i].firstarc=G.vertices[i].firstarc->nextarc;
		}
	}
}
Status TopologicalSort(ALGraph &G)//拓扑排序     
{    
    SqStack S;    
    int i,m,k,v;
	int indegree[1100];     
    ArcNode *p; 
    InitStack(S);
	Findindegree(G,indegree);
	printf("各顶点的入度为：\n"); 
	for(i=0;i<G.vexnum;i++)
	printf("%d ",indegree[i]);
	printf("\n");  
    for(i=0;i<G.vexnum;i++)    
        if(indegree[i]==0)
		{
			 Push(S,i);
		}                   
    m=0;    
    while(!StackEmpty(S))    
    {    
        Pop(S,v);    
		printf("%d ",v);
        m++;    
		for(p=G.vertices[v].firstarc;p!=NULL;p=p->nextarc)  
		{
			 k=p->adjvex;
			 if(!(--indegree[k]))    
                Push(S,k); 
		 }   
    }  
	printf("\n");    
    printf("排序成功\n");     
}    
int main()    
{    
    AMGraph G,T;    
    ALGraph M,N,R;    
    int v,k;    
    printf("************************\n");    
    printf("1.DFS遍历邻接表无向网\n");    
    printf("2.BFS遍历邻接表无向网\n");    
    printf("3.邻接矩阵无向网生成最小生成树\n");    
    printf("4.邻接矩阵有向网生成最短路径\n");     
    printf("5.邻接表有向网生成拓扑序列\n");    
    printf("0.退出\n");    
    printf("************************\n");    
    int choose=-1;    
    while(choose)    
    {    
        printf("请选择: \n");    
        scanf("%d",&choose);    
        switch(choose)    
        {    
            case 1:    
                {    
                    printf("请先创建一个无向网邻接链表\n:");    
                    CreateUDG(M);    
                    printf("创建成功\n");    
                    printf("请输入遍历的起点\n");    
                    scanf("%d",&v);    
                    DFS_AL(M,v);    
                    break;    
                }    
            case 2:    
                {    
                    printf("请先创建一个无向图邻接链表\n");    
                    CreateUDG(N);    
                    printf("创建成功\n");    
                    printf("请输入遍历的起点\n");    
                    scanf("%d",&v);    
                    BFS_AL(N,v);    
                    break;    
                }    
            case 3:    
                {    
                    printf("请先创建一个无向网邻接矩阵\n");    
                    CreateUDN(G);    
                    printf("创建成功\n");    
                    printf("请输入起点\n");    
                    scanf("%d",&k);    
                    MiniSpanTree_Prim(G,k);    
                    break;    
                }    
            case 4:    
                {    
                    printf("请创建一个有向网邻接矩阵\n");    
                    CreateDirUDN(T);    
                    printf("创建成功\n");    
                    printf("请输入起点\n");    
                    scanf("%d",&k);    
                    ShortestPath_DIJ(T,k);    
                    break;    
                }    
            case 5:    
                {    
                    printf("请先创建一个有向网邻接链表\n");    
                    CreateDirUDG(R);    
                    printf("创建成功\n");    
                    TopologicalSort(R);                       
                    break;    
                }     
        }    
    }    
    return 0;    
}


idealistic
关注
  • 0
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图基本操作的编程实现源码
04-24
cout图的基本功能实验(存储结构邻接矩阵)"; cout; cout手工建立（有向）图 "; cout默认数据建立图 "; cout用邻接矩阵形式显示图 "; cout求图的结点数和边数 "; cout求某条边的权值 "; cout添加结点 "; cout...
数据结构-图的基本概念与实现
m0_61789994的博客
05-15 585
图是由若干个节点和它们之间的边组成的一种数据结构。节点也称为顶点，边表示顶点之间的关系。图可以用来描述各种实际问题，如社交网络、地图路线规划、电路设计等。图是一种非常重要的数据结构，它广泛应用于计算机科学和工程领域。本文介绍了图的基本概念、存储方式、遍历算法、最短路径算法和最小生成树算法，希望能够对读者有所帮助。
图的定义、表示、基本操作的实现、遍历
derbi123123的博客
02-09 980
1.什么是图？ 表示多对多的关系。包含： （1）一组顶点：V（vertex） 在线性表中我们称数据对象为元素；在树中称之为结点；在图中就称之为顶点。线性表和树可以有没有数据对象的空表和空树，但空图必须至少有一个顶点，边可以没有。 （2）一组边：E（edge） （3）边还可能有权重：代表一些必要信息。当然，顶点也可能有数据。 图的相关术语： 顶点的度：指与该顶点相连的边的个数，又分为入度和出度，入...
数据结构：图(基础概念及操作，图文解释)
weixin_46015333的博客
03-15 6256
本文介绍了图的概念，包括有向图、无向图，讲了图的基本术语，介绍了长用图的存储结构以及图的基本操作，实现了图的遍历和解释了联通性问题，配以图片更便于理解实践。
数据结构实验项目六 图结构基本操作的实现
WELCOME!!!
12-09 2450
课程名称：数据结构 实验项目名称：图结构基本操作的实现 实验目的： 1．掌握图的基本操作—遍历。 实验要求： 1、分别用DFS和BFS的方法实现一个无向图的遍历。 实验过程： 1、创建一个图（可用邻接矩阵或邻接表的方式进行存储）； 2、输入选项：0或1，0为DFS，1为BFS。 3、分别输出DFS和BFS两种遍历序列； 实验报告中给出DFS和BF...
数据结构之图的基本操作
千寻瀑
04-22 4308
图的基本操作判断边是否存在：列出与某节点相邻的边：在图中插入一个顶点：在图中删除一个顶点：在图中添加一条边：在图中删除一个边：查找某顶点的第一个邻接点：查找某边的权值： 判断边是否存在： ps： 在邻接表中，要搜索某节点的整个边表才能找到是否存在边 在邻接矩阵中，只需要判断该边对应数组位置的值即可 所以从判断是否存在边的角度看，邻接矩阵法更优 列出与某节点相邻的边： 无向图： 在邻接矩阵中，只...
实验六 图基本操作的编程实现
02-09
图基本操作的编程实现（2学时，验证型），掌握图的建立、遍历、插入、删除等基本操作的编程实现，存储结构可以在顺序结构、链接结构、联合使用多种结构等中任选，也可以全部实现。也鼓励学生利用基本操作进行一些...
计算机基本操作-图文.pptx
11-24
计算机基本操作 计算机基本操作是计算机使用的基础知识，本节将详细介绍计算机基本操作的相关知识点。 一、认识计算机 计算机是微型计算机，简称微机，俗称电脑。计算机主要由主机、显示器、键盘、鼠标、音响等几...
图像基本操作.ipynb
05-16
图像基本操作.ipynb
图的邻接矩阵和邻接表表示
06-10
图的C++的邻接表和邻接矩阵完整实现，功能齐全，运行界面效果好
C语言考试模拟系统
07-02
为最新的二级C语言考试模拟系统，希望对大家有帮助
用邻接表实现图的数据结构
01-03
用邻接表实现图的数据结构，链表方式实现，win32+vs2013
像素生存者2V1.68破解版
06-09
像素生存者2V1.68破解版，像素生存者2V1.68破解版，像素生存者2V1.68破解版，像素生存者2V1.68破解版
C4D作品（平面，立体设计）
10-24
C4D作品，可以当做学习C4D的例子吧。也可以做桌面用。
计算机基本操作实验数据结构,数据结构实验——图的基本操作.doc
weixin_35600369的博客
07-14 883
数据结构实验——图的基本操作《数据结构》课程实验报告学院： 班级： 姓名： 学号：实验设备：计算机1台 实验日期：实验项目名称图的基本操作实验目的1)掌握图的邻接矩阵、邻接表的表示方法。2)掌握建立图的邻接矩阵的算法。3)掌握建立图的邻接表的算法。4)加深对图的理解，逐步培养解决实际问题的编程能力。实验要求：①建立一个...
图的操作实验
pq258280920的专栏
07-01 496
图的两种常用的存储结构是邻接矩阵和邻接表，选用哪一种种存储结构，取决于具体的应用。要实现图的遍历操作则用邻接表作为存储结构比较方便。
图的基本操作及应用（邻接表&&邻接矩阵）
qq_43590078的博客
07-05 2539
算法设计与分析 图的基本操作及应用（邻接表&&邻接矩阵） 图的基本操作及应用 1．实验目的 （1）掌握图的基本存储方法； （2）掌握有关图的操作算法并用高级语言实现； （3）熟练掌握图的两种搜索路径的遍历方法。 2．实验内容 （1）图的基本操作 分别用邻接矩阵和邻接表两种方法表示一个无向图，并实现以下操作（完成实验报告）： a. 增加一个结点 b. 删除一个结点 c. 增加一条边 d. 删除一条边 （2）图的应用（选做，参考迪杰斯特拉算法和弗洛伊德算法） 假设以一个带权有向图表示某一区域的
[数据结构] - 图的基本实现
GoodJob
03-26 216
[数据结构] - 图的基本实现 package p1; import java.util.LinkedList; import java.util.Queue; /** * 图 -- (邻接表的实现) * @author Guozhu Zhu * @date 2019/3/26 * @version 1.0 * */ public class Demo01 { pub...
GDAL遥感图像基本操作
最新发布
09-22
GDAL是一个开源的地理数据抽象库，它提供了一系列用于处理遥感图像的基本操作。以下是一些常用的GDAL遥感图像基本操作： 1. 打开遥感图像：使用`gdal.Open()`函数打开遥感图像文件，可以读取遥感图像的元数据和像素...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值