成长路上的小程序之——图的邻接表DFS、BFS

最新推荐文章于 2023-05-16 11:19:30 发布
最新推荐文章于 2023-05-16 11:19:30 发布
阅读量820 收藏
点赞数
分类专栏： 数据结构 成长路上的程序 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011639256/article/details/17184501
版权

第八次数据结构上机内容：使用图的邻接表存储结构完成图的DFS、BFS遍历

本来提前就用邻接矩阵写完了，但昨晚一个贱人突然告诉我老师要求用邻接表写。。。于是加班加点，终于在今早搞出来了！

上机课的时候因为没带书，所以完全是自己敲的，期间被一个无限循环困住了！！！

在邻接链表插入新节点过程中，为p申请新空间，插入后就释放空间

在刘文斌大神的帮助下，我理解了开辟、释放空间这个概念。

我在创建图的过程中，更改了p的指向，并且最后释放p时，p为空指针，所以没有错误。

释放空间时，要确保能够找到之前创建的所有空间并释放！！！！

应该在使用完成后释放空间！！

以后再申请新空间时，无论如何也要放在最后释放空间，这样不容易出错。

代码中还有一个问题就是在FirstAdjVex()和NextAdjVex()函数中，没有释放空间，因为试过只要释放空间就无法使DFS函数结束。

解决方法是在创建空间的时候，另设一个标志指针指向该位置，使用完成后释放标志指针所指空间即可

再次感谢刘文斌大神

得意

代码如下：


#define MAX 20

typedef char VertexType;

typedef struct ArcNode{
      int adjvex;
      int w;
      struct ArcNode *nextarc;
}ArcNode;

typedef struct VNode{
      VertexType data;
      ArcNode *firstarc;
}VNode,AdjList[MAX];

typedef struct{
      AdjList vertices;   
      int vexnum;
      int arcnum;
      int kind;
}ALGraph;

int Locate(ALGraph G,char x)
{
    for(int i=0; i<G.vexnum; i++)
     if(G.vertices[i].data==x) 
      return i;
    return -1; 
} 

Status CreateDG(ALGraph &G)//创建有向图 
{
       char v1,v2; 
       int  j; 
       ArcNode *p;
       printf("\nplease enter the vexnum and arcnum:\n");
       scanf("%d%d",&G.vexnum,&G.arcnum);
       getchar();
       printf("\nplease enter the vexs in order:\n");
       for(int i=0; i<G.vexnum; i++)
       {
        scanf("%c",&G.vertices[i].data);
        G.vertices[i].firstarc=NULL;
       } 
       printf("\nplease enter edge:\n");
       for(int i=0; i<G.arcnum; i++)
       {
        getchar(); 
        scanf("%c %c",&v1,&v2); 
        j=Locate(G,v1); //定位v1位置  
        p=(ArcNode *)malloc(sizeof(ArcNode)); 
        p->adjvex=Locate(G,v2);
        p->w=0;
        p->nextarc=G.vertices[j].firstarc;
        G.vertices[j].firstarc=p;
        //不可以在这里释放空指针！！！
       } 
       printf("\nHere are the ALGraph:\n"); 
       for(int i=0; i<G.vexnum; i++)
       {
        printf("%c",G.vertices[i].data);
        p=(ArcNode *)malloc(sizeof(ArcNode)); 
        p=G.vertices[i].firstarc;
        while(p)     
        {
         printf(" -> %d",p->adjvex);
         p=p->nextarc;    
        }
        printf("\n\n");
       } 
       return OK;
}

Status CreateDN(ALGraph &G)//创建有向网 
{
       char v1,v2; 
       int  j,w; 
       ArcNode *p;
       printf("\nplease enter the vexnum and arcnum:\n");
       scanf("%d%d",&G.vexnum,&G.arcnum);
       getchar();
       printf("\nplease enter the vexs in order:\n");
       for(int i=0; i<G.vexnum; i++)
       {
        scanf("%c",&G.vertices[i].data);
        G.vertices[i].firstarc=NULL;
       } 
       printf("\nplease enter edge:\n");
       for(int i=0; i<G.arcnum; i++)
       {
        getchar(); 
        scanf("%c %c %d",&v1,&v2,&w); 
        j=Locate(G,v1); //定位v1位置  
        p=(ArcNode *)malloc(sizeof(ArcNode)); 
        p->adjvex=Locate(G,v2);
        p->w=w;
        p->nextarc=G.vertices[j].firstarc;
        G.vertices[j].firstarc=p;
        //不可以在这里释放空指针！！！ 
       }
       printf("\nHere are the ALGraph:\n"); 
       for(int i=0; i<G.vexnum; i++)
       {
        printf("%c",G.vertices[i].data);
        p=(ArcNode *)malloc(sizeof(ArcNode)); 
        p=G.vertices[i].firstarc;
        while(p)     
        {
         printf("->[ %d weight:%d ]",p->adjvex,p->w);
         p=p->nextarc;    
        }
        printf("\n\n");
       }
       return OK;
}

Status CreateUDG(ALGraph &G)//创建无向图 
{
       char v1,v2; 
       int  j,k; 
       ArcNode *p,*q,*flag;
       printf("\nplease enter the vexnum and arcnum:\n");
       scanf("%d%d",&G.vexnum,&G.arcnum);
       getchar();
       printf("\nplease enter the vexs in order:\n");
       for(int i=0; i<G.vexnum; i++)
       {
        scanf("%c",&G.vertices[i].data);
        G.vertices[i].firstarc=NULL;
       } 
       printf("\nplease enter edge:\n");
       for(int i=0; i<G.arcnum; i++)
       {
        getchar(); 
        scanf("%c %c",&v1,&v2); 
        j=Locate(G,v1); //定位v1位置  
        k=Locate(G,v2);
        p=(ArcNode *)malloc(sizeof(ArcNode)); 
        q=(ArcNode *)malloc(sizeof(ArcNode));
        p->adjvex=k;
        p->w=0;
        p->nextarc=G.vertices[j].firstarc;
        G.vertices[j].firstarc=p;
        q->adjvex=j;
        q->w=0;
        q->nextarc=G.vertices[k].firstarc;
        G.vertices[k].firstarc=q;
        //不可以在这里释放空指针！！！
       } 
       printf("\nHere are the ALGraph:\n"); 
       for(int i=0; i<G.vexnum; i++)
       {
        printf("%c",G.vertices[i].data);
        p=G.vertices[i].firstarc;
        while(p)     
        {
         printf(" -> %d",p->adjvex);
         p=p->nextarc;    
        }
        printf("\n\n");
       }
       return OK;
}

Status CreateUDN(ALGraph &G)//创建无向网 
{
       char v1,v2; 
       int  j,w,k; 
       ArcNode *p,*q;
       printf("\nplease enter the vexnum and arcnum:\n");
       scanf("%d%d",&G.vexnum,&G.arcnum);
       getchar();
       printf("\nplease enter the vexs in order:\n");
       for(int i=0; i<G.vexnum; i++)
       {
        scanf("%c",&G.vertices[i].data);
        G.vertices[i].firstarc=NULL;
       } 
       printf("\nplease enter edge:\n");
       for(int i=0; i<G.arcnum; i++)
       {
        getchar(); 
        scanf("%c %c %d",&v1,&v2,&w); 
        j=Locate(G,v1); //定位v1位置  
        k=Locate(G,v2);
        p=(ArcNode *)malloc(sizeof(ArcNode)); 
        q=(ArcNode *)malloc(sizeof(ArcNode)); 
        p->adjvex=k;
        p->w=w;
        p->nextarc=G.vertices[j].firstarc;
        G.vertices[j].firstarc=p;
        //不可以在这里释放空指针！！！ 
        q->adjvex=j;
        q->w=w;
        q->nextarc=G.vertices[k].firstarc;
        G.vertices[k].firstarc=q;
       }
       printf("\nHere are the ALGraph:\n"); 
       for(int i=0; i<G.vexnum; i++)
       {
        printf("%c",G.vertices[i].data);
        p=(ArcNode *)malloc(sizeof(ArcNode)); 
        p=G.vertices[i].firstarc;
        while(p)     
        {
         printf("->[ %d weight:%d ]",p->adjvex,p->w);
         p=p->nextarc;    
        }
        printf("\n\n");
       }
       return OK;
}


void CreateMenu(ALGraph &G)
{
    printf("please enter the Graph's kind:\n");
    printf("\n0 present DG(有向图)\n");
    printf("\n1 present DN(有向网)\n");
    printf("\n2 present UDG(无向图)\n");
    printf("\n3 present UDN(无向网)\n");
    char ch=getchar();
    switch(ch)
    {
     case '0':CreateDG(G);break;    
     case '1':CreateDN(G);break;    
     case '2':CreateUDG(G);break;    
     case '3':CreateUDN(G);break;    
    }
    return ;
} 

ArcNode *p;
bool visited[MAX];

int FirstAdjVex(ALGraph G, int v)
{
    p=(ArcNode *)malloc(sizeof(ArcNode)); 
    p=G.vertices[v].firstarc;
    if(p)
     return p->adjvex;
    else return -1;
}

int NextAdjVex(ALGraph G, int v, int w)
{
    p=(ArcNode *)malloc(sizeof(ArcNode)); 
    p=G.vertices[v].firstarc;
    for(int i=0; i<MAX; i++)
    {
     if(p->adjvex==w)
     { 
      if(p->nextarc)
      { 
       return p->nextarc->adjvex;
      } 
      else return -1;
     }
     else
      p=p->nextarc;
    }
}

void DFS(ALGraph G, int v)
{
    visited[v]=true;
    printf("%c   ",G.vertices[v].data);
    for(int w=FirstAdjVex(G,v); w>=0; w=NextAdjVex(G,v,w))
    {
     if(!visited[w])
      DFS(G,w);
    }
    return ;
}

void DFSTraverse(ALGraph G)
{
    printf("\n\n\nHere are the results of DFSTraverse:\n\n");
    int v;
    for(v=0; v<G.vexnum; v++)
     visited[v]=false;
    for(v=0; v<G.vexnum; v++)
     if(!visited[v])
      DFS(G,v);
    printf("\n");
    return ;
}

//----------队列 

void BFSTraverse(ALGraph G)
{
    int que[MAX]={-1}; 
    int u;
    int rear=0,front=0;
    printf("\n\n\nHere are the results of BFSTraverse:\n\n");
    for(int v=0; v<G.vexnum; v++)
     visited[v]=false;
    for(int v=0; v<G.vexnum; v++)
     if(!visited[v])
     {
      visited[v]=true;
      printf("%c   ",G.vertices[v].data);
      que[++rear]=v;
      while(rear!=front)
      {
       u=que[++front];
       for(int w=FirstAdjVex(G,u); w>=0; w=NextAdjVex(G,u,w))
        if(!visited[w])
        {
         visited[w]=true;
         printf("%c   ",G.vertices[w].data);
         que[++rear]=w;   
        }      
      } 
     }
    printf("\n");
}

void menu(ALGraph G)
{
    printf("\n\npleae choice the traverse:");
    printf("\n\n1.DFS\n\n2.BFS\n\n");
    getchar();
    char ch=getchar();
    if(ch=='1')
     return DFSTraverse(G);
    else if(ch=='2')
     return BFSTraverse(G);
}



main函数：

#include <cstdlib>
#include <iostream>
#include "constant.h"
#include "graph.h"

using namespace std;

int main(int argc, char *argv[])
{
    ArcNode *p,*flag; 
    ALGraph G;
    CreateMenu(G);
    menu(G);
    for(int i=0; i<G.vexnum; i++)
    {
     p=G.vertices[i].firstarc;
     while(p)     
     {
      flag=p->nextarc;
      free(p);
      p=flag;
     }
    }
    system("PAUSE");
    return EXIT_SUCCESS;
}


殷华
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构课程设计——实现图的DFS和BFS算法（C语言代码实现）
三月和九月的博客
02-03 1939
一、实验目的及要求 分别构造四种类型图的邻接矩阵存储结构和邻接表存储结构。 输出构造的图。 分别实现图的DFS和BFS算法(存储结构任意)。 在给定的连通网络上求解最小生成树（Prim算法和Kruscal算法任选）。 在给定的有向带权图上实现求关键路径的算法。 在带权的有向图上求解从某一原点出发到其余顶点的最短路径。 以界面的形式展现出相关的选项。 二、实验代码 #include <stdio.h> #include <stdlib.h> #define INFIN
dfs bfs连通区域算法 matlab,【算法】图论(一) —— 基本图算法(BFS/DFS/强连通分量)...
weixin_31924507的博客
03-16 568
基本图算法一、图的表示对于图G=(V,E)，可以用两种表示方法表示，一种将图表示为邻接链表，另一种将图表示为邻接矩阵。这两种方法都既可以表示无向图，又可以表示有向图。1. 邻接链表邻接链表适用于稀疏图(边的条数|E|远小于|V|2的图)。邻接链表由一个包含|V|条链表的数组Adj构成，每个节点有一条链表。若G是无向图，则Adj[u]包含所有与u邻接的节点，所有邻接链表之和为2|E|；若G是有向图，...
图——邻接表和邻接矩阵——DFS、BFS算法
cheng_cuo_tuo的博客
05-30 2581
程序小白，希望和大家多交流，共同学习 //图，将实现图的两种存储，邻接表和邻接矩阵 //并实现图的创建，深度优先遍历（DFS），递归方法和非递归方法，广度优先遍历(BFS) //两种存储方式，在使用深度优先遍历的使用上是一样的 #include&lt;iostream&gt; #include&lt;string&gt; #include&lt;cstdio&gt; #include&lt;s...
【图】（二）图的遍历 - DFS与BFS - C语言
友人帐_的博客
10-30 1069
介绍了图的深度优先搜索与广度优先搜索。并分别给出了邻接矩阵与邻接表两种不同数据结构下的递归与非递归算法。
力扣刷题系列——BFS和DFS
qq_43568704的博客
08-25 1949
BFS与DFS相关算法题 BFS 广度优先搜索（也称宽度优先搜索，缩写BFS，以下采用广度来描述）是连通图的一种遍历算法这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。基本过程，BFS是从根节点开始，沿着树(图)的宽度遍历树(图)的节点。如果所有节点均被访问，则算法中
图的遍历，图的深度优先搜索(DFS)、广度优先搜索(BFS)详解及C++代码详细实现(邻接矩阵版，邻接表版)
weixin_45651616的博客
07-25 1746
图的遍历，使用深度优先搜索(DFS)、广度优先搜索(BFS)遍历图的过程详解及C++代码详细实现(邻接矩阵版、邻接表版)
300分钟搞定数据结构与算法课程学习5 ——DFS和BFS
鱼之天空的博客
05-11 528
DFS 和 BFS 经常在算法面试题当中出现，在整个算法面试知识点中所占的比重非常大。应用最多的地方就是对图进行遍历，树也是图的一种。深度优先搜索（Depth-First Search / DFS） 深度优先搜索，从起点出发，从规定的方向中选择其中一个不断地向前走，直到无法继续为止，然后尝试另外一种方向，直到最后走到终点。就像走迷宫一样，尽量往深处走。 DFS 解决的是连通性的问题，即，给定两个点，一个是起始点，一个是终点，判断是不是有一条路径能从起点连接到终点。起点和终点，也可以指的是某种起始状态和.
图——课上课后练（邻接表法进行拓扑排序、prim法生成最小生成树）
qq_64010161的博客
11-28 3600
图——课上课后练
C++刷题周记(三)——DFS/BFS/拓扑排序
funkoctopus的博客
05-16 209
本周将进入图论的学习，在此之前，我们需要了解dfs/bfs这两种经典的遍历方法。
邻接表存储的图的DFS，BFS遍历
04-06
邻接表存储的图的DFS，BFS遍历。文档描述： http://blog.csdn.net/qq_16912257/article/details/45848935
邻接矩阵，邻接表实现图的创建，遍历(DFS,BFS)
05-12
分别以邻接矩阵和邻接表的方式实现图的深度优先搜索、广度优先搜索
图的BFS（邻接矩阵、邻接表版）
01-07
BFS(u){ queue q; 将u入队; inq[u] = true; //设置u已被加入过队列 while(q非空){ 取出q的队首元素u进行访问; for(从u出发可达到的所有顶点v){ if(inq[v] == false ){ 将v入队; inq[v] = true; ...
图的基本操作dfs，bfs，删除节点（邻接表实现）
03-19
数据结构课程设计 ... （5）输入顶点x,查找图G:若存在含x的顶点,则删除该结点及与之相关连的边,并作DFS遍历(执行操作3)；否则输出信息“无x”； （6）判断图G是否是连通图，输出信息“YES”/“NO”；
图的DFS（邻接矩阵版、邻接表版）
01-07
先上伪码，思路写的比较清楚： 伪代码: DFS(u){ //访问顶点u vis[u] = true;...DFSTrave(G){ //遍历图 for(G的所有顶点){ //对G的所有顶点u if vis[u] == false //如果u未被访问 DFS(u) //访问u所
第七届河南省ACM大学生程序设计大赛 G.Code The Tree
小华在努力~
05-26 1347
题目等网上更新出来了再贴吧 记得我看这个题挺早的，但当时
UVa 442 Matrix Chain Multiplication
小华在努力~
11-13 975
Matrix Chain Multiplication  Suppose you have to evaluate an expression like A*B*C*D*E where A,B,C,D and E are matrices. Since matrix multiplication is associative, the order in which m
成长路上的小程序之——图的邻接矩阵DFS、BFS
小华在努力~
12-07 822
之所以发这篇博客是不甘心我写了这么长的代码，结果一个贱人告诉我存储方式用错了。。。 这里的BFS因为嫌写队列函数太麻烦，所以直接用数组加标识front、rear完成队列的操作，反正节点个数小，使用数组并不会浪费很多空间。 贴上代码纪念一下我曾经二过： #define MAX -1; #define MAX_VERTEX_NUM 20 typedef enum {DG,DN,UDG,UDN}
Codeforces #270 B. Design Tutorial: Learn from Life（数据结构：优先队列模拟题）
小华在努力~
09-29 815
这个题A的莫名其妙，因为没想到怎么做就直接按着题目给出的tizh
c++邻接表实现BFS和DFS
最新发布
05-25
下面是C++实现邻接表的BFS和DFS遍历算法的示例代码： ```c++ #include #include using namespace std; const int MAXN = 100; bool vis[MAXN]; // 记录节点是否被访问过 // 邻接表结构体 struct Edge { int to...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值