DFS和BFS

已于 2024-04-10 22:42:32 修改
阅读量102 收藏
点赞数 1
文章标签： 深度优先 宽度优先 算法
于 2024-04-09 21:40:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tsuki0821/article/details/137568568
版权
文章详细介绍了如何使用C语言实现无向图的数据结构，包括邻接矩阵和邻接列表，并展示了深度优先搜索(DFS)和广度优先搜索(BFS)算法的应用。
摘要由CSDN通过智能技术生成

 邻接矩阵实现无向图：

#include <stdio.h>
#include <stdlib.h>
#include<string.h>
#include<malloc.h>

#define MAX 100
#define LENGTH(a)  (sizeof(a)/sizeof(a[0]))
#define isLetter(a) ((((a)>='a')&&((a)<='z'))||(((a)>='A')&&((a)<='Z')))


//邻接矩阵
typedef struct _graph{
    char vexs[MAX];//顶点集合
    int vexnum;//顶点数
    int edgnum;//边数
    int matrix[MAX][MAX];//临界矩阵
}Graph,*PGraph;
//_graph Graph;*PGraph;

//返回ch在邻接矩阵中的位置
static int get_position(Graph g,char ch){
    int i;
    for(i=0;i<g.vexnum;i++){
        if(g.vexs[i]==ch)
            return i;
    }
    return -1;
}

//读取一个输入字符
static char read_char(){
    char ch;

    do{
    ch=getchar();
    }while(!isLetter(ch));

    return ch;
}

//创建自己输入的图
Graph* creat_graph(){
    char c1,c2;
    int v,e;
    int i,p1,p2;
    Graph* pG;

    //输入顶点数和边数
    printf("输入顶点数：");
    scanf("%d",&v);
    printf("输入边的个数：");
    scanf("%d",&e);
    if(v<1||e<1||(e>v*(v-1))){
        printf("输入错误");
        return NULL;
    }
    if((pG=(Graph*)malloc(sizeof(Graph)))==NULL)
        return NULL;
    memset(pG,0,sizeof(Graph));

    //初始化顶点数和边数
    pG->vexnum=v;
    pG->edgnum=e;
    //初始化顶点
    for(i=0;i<pG->vexnum;i++){
        printf("vertex(%d)：",i);
        pG->vexs[i]=read_char();
    }
    //初始化边
    for(i=0;i<pG->edgnum;i++){
        //读取边的起始顶点和结束顶点
        printf("edge(%d):",i);
        c1=read_char();
        c2=read_char();

        p1=get_position(*pG,c1);
        p2=get_position(*pG,c2);

        if(p1==-1||p2==-1){
            printf("错误输入");
            free(pG);
            return NULL;
        }
        pG->matrix[p1][p2]=1;
        pG->matrix[p2][p1]=1;
    }

    return pG;

}

//用已经提供的图创建矩阵
Graph* creat_example_graph(){
    char vexs[ ] = {'A','B','C','D','E','F','G'};
    char edges[ ][2] = {
        {'A','C'},
        {'A','D'},
        {'A','F'},
        {'B','C'},
        {'C','D'},
        {'E','G'},
        {'F','G'}
    };
    int vlen = LENGTH(vexs);
    int elen = LENGTH(edges);
    int i,p1,p2;
    Graph* pG;
    //printf("%d %d\n",vlen,elen);

    //输入顶点数和边数
    if((pG=(Graph*)malloc(sizeof(Graph))) == NULL)
        return NULL;
    memset(pG,0,sizeof(Graph));

    //初始化顶点数和边数
    pG->vexnum = vlen;
    pG->edgnum = elen;
    //printf("%d %d\n",pG->vexnum,pG->edgnum);
    //初始化顶点
    for(i=0;i<pG->vexnum;i++){
        pG->vexs[i] = vexs[i];
    }
    //初始化边
    for(i=0;i<pG->edgnum;i++){
        //读取边的起始顶点和结束顶点
        p1 = get_position(*pG,edges[i][0]);
        p2 = get_position(*pG,edges[i][1]);
        //printf("%d %d\n",p1,p2);
        pG->matrix[p1][p2] = 1;
        pG->matrix[p2][p1] = 1;
    }

    return pG;
}

void DFSTraverse(Graph G){
    int i;
    int visited[MAX];

    //初始化所有顶点都没有被访问
    for(i=0;i<G.vexnum;i++)
        visited[i]=0;

    printf("DFS:");
    for(i=0;i<G.vexnum;i++){
        if(!visited[i])
            DFS(G,i,visited);
    }

}

//深度优先搜索遍历图的递归实现
void DFS(Graph G,int i,int *visited ){
    int w;

    visited[i] = 1;
    printf("%c ",G.vexs[i]);
    //遍历该顶点的所有邻接顶点，如果是没有访问过的，就继续往下走
    for(w = first_vertex(G,i);w >=0;w = next_vertix(G,i,w)){
        if(!visited[w])
            DFS(G,w,visited);
    }
}

//返回顶点v的第一个邻接顶点的索引，失败则返回-1
int first_vertex(Graph G,int v){
    int i;

    if(v<0||v>(G.vexnum-1))
        return -1;

    for(i=0;i<G.vexnum;i++){
        if(G.matrix[v][i] == 1)
            return i;
    }

    return -1;

}

//返回顶点v相对于w的下一个邻接顶点的索引，失败则返回-1
int next_vertix(Graph G,int v,int w){
    int i;

    if(v<0||v>(G.vexnum-1)||w<0||w>(G.vexnum-1))
        return -1;

    for(i=w+1;i<G.vexnum;i++){
        if(G.matrix[v][i]==1)
            return i;
    }
    return -1;
}

//广度优先搜索
static void BFS(Graph G){
    int head=0;
    int rear=0;
    int queue[MAX];//辅助队列
    int visited[MAX];//顶点访问标记
    int i,j,k;

    for(i=0;i<G.vexnum;i++){
        visited[i]=0;
    }

    printf("BFS: ");
    for(i=0;i<G.vexnum;i++){
        if(!visited[i]){
            visited[i]=1;//如果没有被访问，则将访问数组置为1，再进行输出，再入队列
            printf("%c ",G.vexs[i]);
            queue[rear++]=i;//入队列
        }
        while(head!=rear){
             j=queue[head++];//出队列
             for(k=first_vertex(G,j);k>=0;k=next_vertix(G,j,k)){
                if(!visited[k]){
                    visited[k]=1;
                    printf("%c ",G.vexs[k]);
                    queue[rear++]=k;
                }
             }
        }
    }
    printf("\n");
}

//打印矩阵队列
void print_graph(Graph G){
    int i,j;

    printf("无向图邻接矩阵:\n");
    for(i=0;i<G.vexnum;i++){
        for(j=0;j<G.vexnum;j++){
            printf("%d",G.matrix[i][j]);
        }
        printf("\n");
    }
}

int main()
{
    Graph *pG;

    //自定义图（输入矩阵队列）
    pG = creat_graph();
    //采用已有的图
    //pG  = creat_example_graph();

    print_graph(*pG);//打印出创建的图
    DFSTraverse(*pG);//深度优先搜索
    BFS(*pG);//广度优先搜索
    return 0;
}

领接表实现无向图：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>


#define MAX 100
#define LENGTH(a) (sizeof(a)/sizeof(a[0]))

//领接表中的表对应的链表的顶点
typedef struct _ENode{
    int ivex;//该边所指向的顶点的位置
    struct _ENode* next_edge;//指向下一条弧的指针
}ENode,*PENode;

//邻接表中的表的顶点
typedef struct _VNode{
    char data;//顶点信息
    ENode *first_edge;//指向第一条依附该顶点的弧
}VNode;

//邻接表
typedef struct _LGraph{
    int vexnum;//图的顶点个数
    int edgnum;//图的边的数目
    VNode vexs[MAX];
}LGraph;

//返回ch在邻接节点数组里面的位置

int get_position(LGraph g,char ch){
    int i;
    for(i=0;i<g.vexnum;i++){
        if(g.vexs[i].data==ch)
            return i;
    }
    return -1;
}

//将enode顶点链接到List的末尾
void link_last(ENode* list,ENode* node){
    ENode* p=list;
    while(p->next_edge)
        p=p->next_edge;
    p->next_edge=node;
}


//创建自定义的图
LGraph* creat_lgraph(){
    
}

//创建已有的图
LGraph* creat_example_lgraph(){
    char c1,c2;
    char vexs[ ]={'A','B','C','D','E','F','G'};
    char edges[ ][2]={
    {'A','C'},
    {'A','D'},
    {'A','F'},
    {'B','C'},
    {'C','D'},
    {'E','G'},
    {'F','G'}};
    int vlen=LENGTH(vexs);
    int elen=LENGTH(edges);
    int i,p1,p2;
    ENode *node1,*node2;
    LGraph* pG;

    if((pG=(LGraph*)malloc(sizeof(LGraph)))==NULL)
        return NULL;
    memset(pG,0,sizeof(LGraph));

    //初始化顶点数和边数
    pG->vexnum=vlen;
    pG->edgnum=elen;

    //初始化顶点
    for(i=0;i<pG->vexnum;i++){
        pG->vexs[i].data=vexs[i];
        pG->vexs[i].first_edge=NULL;
    }

    //初始化领接表的边
    for(i=0;i<pG->edgnum;i++){
        c1=edges[i][0];
        c2=edges[i][1];

        p1=get_position(*pG,c1);
        p2=get_position(*pG,c2);
        //printf("%d %d\n",p1,p2);
        //初始化节点1
        node1=(ENode*)malloc(sizeof(ENode));
        node1->ivex=p2;
        node1->next_edge=NULL;
        //将node1链接到节点的末尾
        if(pG->vexs[p1].first_edge==NULL)
            pG->vexs[p1].first_edge=node1;
        else
            link_last(pG->vexs[p1].first_edge,node1);


        //初始化节点2
        node2=(ENode*)malloc(sizeof(ENode));
        node2->ivex=p1;
        node2->next_edge=NULL;
        //将节点2链接到节点的末尾
        if(pG->vexs[p2].first_edge==NULL)
            pG->vexs[p2].first_edge=node2;
        else
            link_last(pG->vexs[p2].first_edge,node2);
    }
    return pG;
}


//深度优先搜索
void DFSTraverse(LGraph G){
    int i;
    int visited[MAX];

    //初始化所有顶点都没有被访问
    for(i=0;i<G.vexnum;i++){
        visited[i]=0;
    }
    printf("DFS访问结果：");
    for(i=0;i<G.vexnum;i++){
        if(visited[i]!=1)
            DFS(G,i,visited);
    }
    printf("\n");
}

//DFS递归搜索
void DFS(LGraph G,int i,int *visited){
         int w;
         ENode *node;

         visited[i]=1;
         printf("%c",G.vexs[i].data);
         node=G.vexs[i].first_edge;
         while(node!=NULL){
            if(!visited[node->ivex]){
                DFS(G,node->ivex,visited);
            }
            node=node->next_edge;
         }
}

//广度优先搜索
void BFS(LGraph G){
    int head=0;
    int rear=0;
    int queue[MAX];
    int visited[MAX];
    int i,j,k;
    ENode* node;

    for(i=0;i<G.vexnum;i++){
        visited[i]=0;
    }
    printf("BFS访问结果：");
    for(i=0;i<G.vexnum;i++){
        if(!visited[i]){
            visited[i]=1;
            printf("%c",G.vexs[i].data);
            queue[rear++]=i;
        }
        while(head!=rear){
            j=queue[head++];
            node=G.vexs[j].first_edge;
            while(node!=NULL){
                k=node->ivex;
                if(!visited[k]){
                    visited[k]=1;
                    printf("%c",G.vexs[k].data);
                    queue[rear++]=k;
                }
                node=node->next_edge;
            }
        }
    }
    printf("\n");
}

//打印邻接表图
void print_lgraph(LGraph G){
    int i,j;
    ENode* node;

    printf("领接表图：\n");
    for(i=0;i<G.vexnum;i++){
        printf("%d(%c):",i,G.vexs[i].data);
        node=G.vexs[i].first_edge;
        while(node!=NULL){
            printf("%d(%c)  ",node->ivex,G.vexs[node->ivex].data);
            node=node->next_edge;
        }
        printf("\n");
    }
}

int  main(){
    LGraph *pG;
    //自己创建图
    pG=creat_lgraph();
    //用已经有的图
    //pG=creat_example_lgraph();

    print_lgraph(*pG);
    DFSTraverse(*pG);
    BFS(*pG);
    return 0;
}

Tsuki0821
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
DFS和BFS简述
蓝的博客
02-01 3179
DFS与BFS
DFS和BFS.docx
08-21
在C++中，DFS和BFS通常结合队列（for BFS）和栈（for DFS）数据结构实现。在搜索过程中，需要使用标志数组或其他数据结构来记录已经访问过的节点，防止无限循环和重复访问。 总的来说，DFS和BFS是图论和算法中的...
图文详解 DFS 和 BFS
tyrroo的博客
08-31 2381
前言 深度优先遍历（Depth First Search, 简称 DFS） 与广度优先遍历（Breath First Search）是图论中两种非常重要的算法，生产上广泛用于拓扑排序，寻路（走迷宫），搜索引擎，爬虫等，也频繁出现在 leetcode，高频面试题中。 本文将会从以下几个方面来讲述深度优先遍历，广度优先遍历，相信大家看了肯定会有收获。 深度优先遍历，广度优先遍历简介 习题演练 DFS，BFS 在搜索引擎中的应用 深度优先遍历，广度优先遍历简介 深度优先遍历 深度优先遍历主要思路是从
dfs和bfs算法详解
编程小弟的博客
04-17 1313
DFS和BFS是两种基础且强大的图遍历算法，它们在解决各种实际问题时发挥着重要作用。通过了解它们的原理、实现细节以及变种和优化策略，我们可以更加灵活地运用这些算法来解决实际问题。同时，在选择使用DFS还是BFS时，我们需要根据问题的特点、图的性质以及时间和空间复杂度的要求来进行权衡和选择。
DFS和BFS的区别
YoungGeeker
08-19 4446
很多人在看别人代码时，总会看到DFS、BFS这样的函数，那么它们又有什么区别呢？本文就向大家详细讲解一下。
图的 DFS 和BFS
07-09
图的深度优先搜索（DFS, Depth First Search）和广度优先搜索（BFS, Breadth First Search）是图论中的两种重要算法，用于遍历或搜索树或图。这两种算法在计算机科学中有着广泛的应用，比如在路径查找、拓扑排序、...
dfs和bfs算法详解.md
04-13
dfs和bfs算法 DFS（深度优先搜索）和BFS（广度优先搜索）是两种用于遍历或搜索树或图的算法。它们的主要区别在于访问节点的顺序。 1. **深度优先搜索（DFS）** 深度优先搜索是一种用于遍历或搜索树或图的算法。这...
DFS和BFS笔记
01-20
BFS 先记录广度优先搜索，我理解的广度优先搜索，即是从某点（父结点）出发，按层次遍历后续子节点。如上图所示，我们选取A点为父结点，则接下来应当遍历与A节点直接相邻的B, C节点，我们按顺序将节点记录在python...
DFS和BFS用来干什么
05-01
DFS和BFS DFS（Depth-First-Search）深度优先搜索算法，是搜索算法的一种。是一种在开发爬虫早期使用较多的方法。它的目的是要达到被搜索结构的叶结点 宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5145
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
备战秋招60天算法挑战，Day17
溜达虎的博客
08-13 281
给定两个字符串 和 ，编写一个函数来判断 是否是 的字母异位词。注意： 若 和 中每个字符出现的次数都相同，则称 和 互为字母异位词。举个例子： 视频题解 有效的字母异位词 思路来源 思路来源 思路解析 方法一 排序 分别对和进行排序，然后比较排序后的字符串是否相等。 java代码 python代码 复杂度分析 时间复杂度： 快排的时间复杂度是O(nlogn)，其中是字符串的长度。空间复杂度： 快排的空间复杂度是O(logn)。假设， 。 java代码 python代码 复杂度分析 时
day 9 回溯算法
m0_73924943的博客
08-08 396
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
代码随想录算法训练营第十一天
b1ankwall的博客
08-10 1233
参加代码随想录第43期算法训练营day11|150. 逆波兰表达式求值，239. 滑动窗口最大值，347.前 K 个高频元素，栈与队列总结
[算法2] 第二集 二叉树中的深度搜索
2301_80017277的博客
08-09 870
一、（DFS，全称为 Depth First Traversal），是我们树或者图这样的数据结构中常⽤的⼀种遍历算法。这个算法会尽可能深的搜索树或者图的分支，直到⼀条路径上的所有节点都被遍历完毕，然后再回溯到上⼀层，继续找⼀条路遍历。在⼆叉树中，常见的深度优先遍历为：前序遍历、中序遍历以及后序遍历。因为树的定义本⾝就是递归定义，因此采⽤递归的方法去实现树的三种遍历不仅容易理解⽽且代码很简洁。
算法：外卖调度
最新发布
m0_73915763的博客
08-13 781
有N个餐厅和M个外卖员，每个餐厅在某个时间点会产生一个外卖订单，这些订单都有产生时间、所需送达时间和优先级。外卖员在空闲时会选择最优先的订单来配送，直到所有订单都被送达。具体规则如下: 对于每个餐厅的订单，优先级高的订单优先，其次是所需送达时间最短的订单，再次是产生时间最早的订单。外卖员在空闲时会从所有餐厅的最高优先级订单中挑选一个所需送达时间最短的订单进行配送，若所需送达时间相同则选择餐厅编号最小的订单。
经典算法题总结：十大排序算法，外部排序和Google排序简介
技术研究记录
08-10 561
快速排序（Quick Sort）是一种常用的高效的排序算法，它是一种基于比较的排序算法，利用了分治（自顶向下）的思想。快速排序的主要思想是选择一个基准元素，将数组分成两个子数组，一个子数组的所有元素都小于基准元素，另一个子数组的所有元素都大于基准元素，然后递归地对这两个子数组进行排序，最后将它们合并起来。
【算法】二分查找
2301_80277275的博客
08-10 273
二分查找、在排序数组中查找元素的第一个和最后一个位置、x的平方根、搜索插入位置、山脉数组的峰顶索引、寻找峰值、寻找旋转排序数组中的最小值、点名
C语言 | Leetcode C语言题解之第332题重新安排行程
m0_59237910的博客
08-13 385
C语言 | Leetcode C语言题解之第332题重新安排行程
dfs和bfs python
03-26
深度优先搜索（DFS）和广度优先搜索（BFS）是常用的图搜索算法，它们可以应用于迷宫、排列组合、树结构等问题。下面是Python实现DFS和BFS的样例代码： DFS: ```python def dfs(graph, start, visited=set()): ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值