数据结构与算法基础-学习-24-图的遍历之DFS（深度优先搜索）和BFS（广度优先搜索）

已于 2023-06-27 14:32:25 修改
阅读量2.8k 收藏 5
点赞数 2
分类专栏： # 数据结构与算法基础学习 文章标签： 深度优先 宽度优先 数据结构 算法 c语言
于 2023-05-30 15:03:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45111959/article/details/130941333
版权

目录

一、遍历定义

二、遍历实质

三、DFS

四、BFS

五、宏定义

六、自定义类型

七、函数实现

1、DFS（邻接矩阵实现）

2、DFS（邻接表实现）

3、BFS（邻接矩阵实现）

4、BFS（邻接表实现）

5、打印邻接矩阵遍历顺序

 6、打印邻接表遍历顺序

八、遍历算法效率分析

1、DFS

2、BFS

九、Linux编译测试

一、遍历定义

从已给的连通图中某一顶点出发，沿着一些边访问遍图中所有顶点，且使每个顶点仅被访问一次，就叫做的图的遍历，它是图的基本运算。

二、遍历实质

找每个顶点的邻接点的过程。

三、DFS

深度优先搜索，英文全称Depth First Search。如下图进行举例说明。

这里以邻接矩阵表示无向图进行举例，生成内容如下：

[2023-5]--[ Debug ]--Printf AMGraph                     :
VertexArray    : [A ,B ,C ,D ,E ]
ArcArray       :
[32767 ,20    ,30    ,10    ,32767 ]
[20    ,32767 ,32767 ,32767 ,50    ]
[30    ,32767 ,32767 ,40    ,32767 ]
[10    ,32767 ,40    ,32767 ,60    ]
[32767 ,50    ,32767 ,60    ,32767 ]
CurVertexNum   : 5
CurArcNum      : 12

 我们还需要维护一个Visit数组，用于确认访问过的节点有哪些，0表示没有访问过，1表示访问过。

 例如我们从E出发，Visit数组变为：

从邻接矩阵上看，E->B和E->D，DFS算法是一条道走到黑，先扫到B节点，又发现B节点没有被访问，所以先走E->B。

[32767 ,50    ,32767 ,60    ,32767 ]

Visit数组变为：

从邻接矩阵上看B的情况，可以走B->A和B->E，先发现的A节点，又发现A节点没有被访问，所以先走B->A。

[20    ,32767 ,32767 ,32767 ,50    ]

Visit数组变为：

从邻接矩阵上看A的情况，可以走A->B和A->C，A->D，先发现的B节点，又发现B节点被访问过，所以跳过，再看C节点发现没有被访问，所以先走A->C。

[32767 ,20    ,30    ,10    ,32767 ]

Visit数组变为：

从邻接矩阵上看C的情况，可以走C->A和C->D，先发现的A节点，又发现A节点被访问过，所以跳过，再看D节点发现没有被访问，所以先走C->D。

[30    ,32767 ,32767 ,40    ,32767 ]

Visit数组变为：

 最后发现Visit数组中的所有节点被访问完，退出程序。

四、BFS

广度优先搜索，英文全称Breadth First Search，BFS类似于树的层次遍历，我们可以将图逆时针旋转90度，如下图进行举例说明。

旋转后：

这里以邻接矩阵表示无向图进行举例，生成内容如下：

[2023-5]--[ Debug ]--Printf AMGraph                     :
VertexArray    : [A ,B ,C ,D ,E ]
ArcArray       :
[32767 ,20    ,30    ,10    ,32767 ]
[20    ,32767 ,32767 ,32767 ,50    ]
[30    ,32767 ,32767 ,40    ,32767 ]
[10    ,32767 ,40    ,32767 ,60    ]
[32767 ,50    ,32767 ,60    ,32767 ]
CurVertexNum   : 5
CurArcNum      : 12

和DFS一样我们也需要维护一个Visit数组，用于确认访问过的节点有哪些，0表示没有访问过，1表示访问过。

我们还需要维护一个队列，没错思路和层次遍历一样。

 例如我们还是从E出发，Visit数组变为：

队列变为：

[2023-5]--[ Debug ]--SqQueue Data   :
Data           : [ 4 ]
FrontIndex     : 0
RearIndex      : 1
SqQueueLen     : 1

从邻接矩阵上看E，E->B和E->D，BFS算法是广度优先，会先把E可以访问的节点先都走一遍，判断BD是否被访问，都没有被访问，那就依次访问E->B和E->D。

[32767 ,50    ,32767 ,60    ,32767 ]

Visit数组变为：

队列弹出E，压入BD变为：

[2023-5]--[ Debug ]--SqQueue Data   :
Data           : [ 1 ,3 ]
FrontIndex     : 1
RearIndex      : 3
SqQueueLen     : 2

队列中弹出B，从邻接矩阵上看B的情况，可以走B->A和B->E，发现A节点没有被访问,压入队列中，E被访问过，不压入，所以走B->A。

[20    ,32767 ,32767 ,32767 ,50    ]

Visit数组变为：

 队列，弹出B，压入A变为：

[2023-5]--[ Debug ]--SqQueue Data   :
Data           : [ 3 ,0 ]
FrontIndex     : 2
RearIndex      : 4
SqQueueLen     : 2

弹出D,从邻接矩阵上看D的情况，可以走D->A和D->C，D->E，发现A节点被访问过，所以跳过，再看C节点发现没有被访问，所以先走D->C，发现所有节点都被访问，退出程序。

[10    ,32767 ,40    ,32767 ,60    ]

Visit数组变为：

五、宏定义

#define MAX_INT_TYPE_NUM      32767 //网中代表无穷大，也代表顶点个数。
#define MAX_VERTEX_NUM        10000 //顶点数组中存放顶点的最大个数。
#define NET_DIRECTION_FLAG    0     //有向网的标志
#define NET_UNDIRECTION_FLAG  1     //无向网的标志

//DFS,BFS
#define VISITED_FLAG          1
#define NOT_VISITED_FLAG      0

六、自定义类型

//DFS,BFS
typedef struct AccessSeqType
{
    VertexIndexType Array[MAX_VERTEX_NUM];
    VertexIndexType ArraySize;
}AccessSeqType;

这是一个访问顺序数组，方便查看访问顺序的。

邻接矩阵和邻接表的定义和相关代码可以参考之前的文章《数据结构与算法基础-学习-23-图之邻接矩阵与邻接表》

七、函数实现

1、DFS（邻接矩阵实现）

void DepthFirstSearchUseAMGraph(AMGraph* AMG, VertexIndexType VertexIndex, VertexIndexType* VisitedArray, AccessSeqType* AccessSeq)
{
    AccessSeq->Array[AccessSeq->ArraySize] = VertexIndex;
    AccessSeq->ArraySize++;

    VisitedArray[VertexIndex] = VISITED_FLAG;
    VertexIndexType ColIndex;

    if(AccessSeq->ArraySize == AMG->CurVertexNum)//如果所有结点访问完成，退出。
    {
        return;
    }
    //GlobalCnt++;
    
    for(ColIndex = 0; ColIndex < AMG->CurVertexNum; ColIndex++)
    {
        //GlobalCycleCnt++;
        if(AMG->ArcArray[VertexIndex][ColIndex] != MAX_INT_TYPE_NUM && VisitedArray[ColIndex] == NOT_VISITED_FLAG)
        {
            DepthFirstSearchUseAMGraph(AMG, ColIndex, VisitedArray, AccessSeq);
            if(AccessSeq->ArraySize == AMG->CurVertexNum)//如果所有结点访问完成，退出。
            {
                break;
            }
        }
    }
}
参数名描述
AMG邻接矩阵。
VertexIndex从哪个顶点索引号开始搜索。
VisitedArray顶点访问数组。
AccessSeq顶点访问顺序数组。

2、DFS（邻接表实现）

void DepthFirstSearchUseAGraph(AGraph* AG, VertexIndexType VertexIndex, VertexIndexType* VisitedArray, AccessSeqType* AccessSeq)
{
    AccessSeq->Array[AccessSeq->ArraySize] = VertexIndex;
    AccessSeq->ArraySize++;

    VisitedArray[VertexIndex] = VISITED_FLAG;
    //GlobalCnt++;

    if(AccessSeq->ArraySize == AG->VertexNum)//如果所有结点访问完成，退出。
    {
        return;
    }
    
    ArcNode* TmpArcNode = AG->Vertices[VertexIndex].FirstArcNodePtr;;
 
    while(TmpArcNode != NULL)
    {
        //GlobalCycleCnt++;
        if(VisitedArray[TmpArcNode->EndVertexIndex] == NOT_VISITED_FLAG)
        {
            DepthFirstSearchUseAGraph(AG, TmpArcNode->EndVertexIndex, VisitedArray, AccessSeq);
            if(AccessSeq->ArraySize == AG->VertexNum)//如果所有结点访问完成，退出。
            {
                break;
            }
        }
        TmpArcNode = TmpArcNode->NextNodePtr;
    }
}
参数名描述
AG邻接表。
VertexIndex从哪个顶点索引号开始搜索。
VisitedArray顶点访问数组。
AccessSeq顶点访问顺序数组。

3、BFS（邻接矩阵实现）

void BreadthFirstSearchUseAMGraph(AMGraph* AMG, VertexIndexType VertexIndex, VertexIndexType* VisitedArray, AccessSeqType* AccessSeq)
{
    JudgeAllNullPointer(VisitedArray);
    JudgeAllNullPointer(AccessSeq);

    SqQueue* SQ              = NULL;
    VertexIndexType* TmpElem = (VertexIndexType*)MyMalloc(sizeof(VertexIndexType));
    VertexIndexType  i       = 0;

    InitSqQueue(&SQ,INT_TYPE_FLAG);//初始化循环顺序队   
    EnterSqQueue(SQ, &VertexIndex);//将第一个结点压入循环顺序队。
    VisitedArray[VertexIndex]              = VISITED_FLAG;
    AccessSeq->Array[AccessSeq->ArraySize] = VertexIndex;
    AccessSeq->ArraySize++;

    while(GetSqQueueLen(SQ) != 0)
    {
        PrintfSqQueue(SQ);
        LeaveSqQueue(SQ, TmpElem);
        for(i = 0; i < AMG->CurVertexNum; i++)
        {
            if(AMG->ArcArray[*TmpElem][i] != MAX_INT_TYPE_NUM && VisitedArray[i] == NOT_VISITED_FLAG)
            {
                EnterSqQueue(SQ, &i);
                VisitedArray[i]                        = VISITED_FLAG;
                AccessSeq->Array[AccessSeq->ArraySize] = i;
                AccessSeq->ArraySize++;
                if(AccessSeq->ArraySize == AMG->CurVertexNum)//如果所有结点访问完成，退出。
                {
                    break;
                }
            }
        }
        if(AccessSeq->ArraySize == AMG->CurVertexNum)//如果所有结点访问完成，退出。
        {
            break;
        }
    }

    DestroySqQueue(&SQ);
    free(TmpElem);
    TmpElem = NULL;

    Log("Breadth First Search Use AMGraph OK\n",Debug);
}
参数名描述
AMG邻接矩阵。
VertexIndex从哪个顶点索引号开始搜索。
VisitedArray顶点访问数组。
AccessSeq顶点访问顺序数组。

感觉访问顺序数组满退出这一块，两次break，写成goto是不是好些，大家有想法的可以指点小弟一二。

4、BFS（邻接表实现）

void BreadthFirstSearchUseAGraph(AGraph* AG, VertexIndexType VertexIndex, VertexIndexType* VisitedArray, AccessSeqType* AccessSeq)
{
    JudgeAllNullPointer(VisitedArray);
    JudgeAllNullPointer(AccessSeq);

    SqQueue* SQ              = NULL;
    VertexIndexType* TmpElem = (VertexIndexType*)MyMalloc(sizeof(VertexIndexType));
    ArcNode*         TmpNode = NULL;

    InitSqQueue(&SQ,INT_TYPE_FLAG);//初始化循环顺序队   
    EnterSqQueue(SQ, &VertexIndex);//将第一个结点压入循环顺序队。
    VisitedArray[VertexIndex]              = VISITED_FLAG;
    AccessSeq->Array[AccessSeq->ArraySize] = VertexIndex;
    AccessSeq->ArraySize++;

    while(GetSqQueueLen(SQ) != 0)
    {
        LeaveSqQueue(SQ, TmpElem);
        TmpNode                                = AG->Vertices[*TmpElem].FirstArcNodePtr;
        while(TmpNode != NULL)
        {
            if(VisitedArray[TmpNode->EndVertexIndex] == NOT_VISITED_FLAG)
            {
                EnterSqQueue(SQ, &(TmpNode->EndVertexIndex));
                VisitedArray[TmpNode->EndVertexIndex]  = VISITED_FLAG;
                AccessSeq->Array[AccessSeq->ArraySize] = TmpNode->EndVertexIndex;
                AccessSeq->ArraySize++;
                if(AccessSeq->ArraySize == AG->VertexNum)//如果所有结点访问完成，退出。
                {
                    break;
                }
            }
            TmpNode = TmpNode->NextNodePtr;
        }
        if(AccessSeq->ArraySize == AG->VertexNum)//如果所有结点访问完成，退出。
        {
            break;
        }
    }

    DestroySqQueue(&SQ);
    free(TmpElem);
    TmpElem = NULL;
    Log("Breadth First Search Use AGraph OK\n",Debug);
}
参数名描述
AG邻接表。
VertexIndex从哪个顶点索引号开始搜索。
VisitedArray顶点访问数组。
AccessSeq顶点访问顺序数组。

5、打印邻接矩阵遍历顺序

Status AMGraphTraverse(void (*Func)(AMGraph*,VertexIndexType,VertexIndexType*, AccessSeqType*),AMGraph* AMG, VertexIndexType VertexIndex)
{
    JudgeAllNullPointer(AMG);

    VertexIndexType* VisitedArray = (VertexIndexType*)MyCalloc(AMG->CurVertexNum, sizeof(VertexIndexType));
    AccessSeqType* AccessSeq      = (AccessSeqType*)MyCalloc(1, sizeof(AccessSeqType));
    AccessSeq->ArraySize          = 0;

    Func(AMG, VertexIndex, VisitedArray, AccessSeq);

    char* string = (char*)MyCalloc(STR_TYPE_SIZE, sizeof(char));
    CopyStr* PS  = (CopyStr*)malloc(sizeof(CopyStr));
    InitCopyStr(PS);
    ExecCopyStr(PS,"Traverse Use AMGraph               : [");
    VertexIndexType i;
    for(i = 0; i < AccessSeq->ArraySize; i++)
    {
        sprintf(string,"%d ,", AccessSeq->Array[i]);
        ExecCopyStr(PS,string);
    }
    PS->String[PS->StrEffectiveLen-1] = ']';
    ExecCopyStr(PS,"\n");

    free(AccessSeq);
    free(VisitedArray);
    AccessSeq    = NULL;
    VisitedArray = NULL;

    PS->String[PS->StrEffectiveLen] = '\0';
    Log(PS->String, Debug);
    DestroyCopyStr(PS);
    free(string);
    string       = NULL;
    return SuccessFlag;
}
参数名描述
FuncDFS或BFS函数指针。
AMG邻接矩阵。
VertexIndex从哪个顶点索引号开始搜索。

 6、打印邻接表遍历顺序

Status AGraphTraverse(void (*Func)(AGraph*,VertexIndexType,VertexIndexType*,AccessSeqType*),AGraph* AG, VertexIndexType VertexIndex)
{
    JudgeAllNullPointer(AG);

    VertexIndexType* VisitedArray = (VertexIndexType*)MyCalloc(AG->VertexNum, sizeof(VertexIndexType));
    AccessSeqType* AccessSeq      = (AccessSeqType*)MyCalloc(1, sizeof(AccessSeqType));
    AccessSeq->ArraySize          = 0;

    Func(AG, VertexIndex, VisitedArray, AccessSeq);

    char* string = (char*)MyCalloc(STR_TYPE_SIZE, sizeof(char));
    CopyStr* PS  = (CopyStr*)malloc(sizeof(CopyStr));
    InitCopyStr(PS);
    ExecCopyStr(PS,"Traverse Use AGraph                : [");
    VertexIndexType i;
    for(i = 0; i < AccessSeq->ArraySize; i++)
    {
        sprintf(string,"%d ,", AccessSeq->Array[i]);
        ExecCopyStr(PS,string);
    }
    PS->String[PS->StrEffectiveLen-1] = ']';
    ExecCopyStr(PS,"\n");

    free(AccessSeq);
    free(VisitedArray);
    AccessSeq    = NULL;
    VisitedArray = NULL;

    PS->String[PS->StrEffectiveLen] = '\0';
    Log(PS->String, Debug);
    DestroyCopyStr(PS);
    free(string);
    string       = NULL;
    return SuccessFlag;
}
参数名描述
FuncDFS或BFS函数指针。
AG邻接表。
VertexIndex从哪个顶点索引号开始搜索。

八、遍历算法效率分析

1、DFS

用邻接矩阵表示图，遍历图中每一个顶点都要从头扫描该顶点所在行，时间复杂度为O(n^2)。

用邻接表表示图，虽然有2e个表结点，但只需要扫描e个结点即可完成遍历，加上访问n个头节点的时间，时间复杂度为O(n+e)。

2、BFS

使用邻接矩阵，则BFS对于每一个被访问到的顶点，都要循环检测矩阵中的整整一行（n个元素），总的时间代价为O(n^2)。

用邻接表表示图，虽然有2e个表结点，但只需要扫描e个结点即可完成遍历，加上访问n个头节点的时间，时间复杂度为O(n+e)。

九、Linux编译测试

[gbase@czg2 Graph]$ make
gcc -Wall -Wextra -O3 ../Log/Log.c ../PublicFunction/PublicFunction.c ../PublicFunction/SqQueue/SqQueue.c Graph.c MinimumSpanningTree.c main.c -o TestGraph -I ../Log/ -I ../PublicFunction/ -I ../Select/ -I ../PublicFunction/SqQueue/
[gbase@czg2 Graph]$ ./TestGraph 
[2023-5]--[ Info  ]--Create Net Data                    : OK
[2023-5]--[ Info  ]--Create Undirection Net Use AMGraph : OK
[2023-5]--[ Debug ]--Printf AMGraph                     :
VertexArray    : [A ,B ,C ,D ,E ]
ArcArray       :
[32767 ,20    ,30    ,10    ,32767 ]
[20    ,32767 ,32767 ,32767 ,50    ]
[30    ,32767 ,32767 ,40    ,32767 ]
[10    ,32767 ,40    ,32767 ,60    ]
[32767 ,50    ,32767 ,60    ,32767 ]
CurVertexNum   : 5
CurArcNum      : 12
[2023-5]--[ Info  ]--Create Undirection Net Use AGraph  : OK
[2023-5]--[ Debug ]--Printf AGraph                      :
A : [(2, 30, 0x6f18b0),(1, 20, 0x6f1870),(3, 10, (nil))]
B : [(4, 50, 0x6f18d0),(0, 20, (nil))]
C : [(3, 40, 0x6f1910),(0, 30, (nil))]
D : [(4, 60, 0x6f1950),(2, 40, 0x6f1890),(0, 10, (nil))]
E : [(3, 60, 0x6f1990),(1, 50, (nil))]
VertexNum      : 5
ArcNum         : 12
[2023-5]--[ Debug ]--Traverse Use AMGraph               : [4 ,1 ,0 ,2 ,3 ]
[2023-5]--[ Debug ]--Traverse Use AGraph                : [4 ,3 ,2 ,0 ,1 ]
[2023-5]--[ Debug ]--Init SqQueue Normal
[2023-5]--[ Debug ]--Enter SqQueue Normal
[2023-5]--[ Debug ]--SqQueue Data   :
Data           : [ 4 ]
FrontIndex     : 0
RearIndex      : 1
SqQueueLen     : 1
Flag           : INT_TYPE_FLAG
[2023-5]--[ Debug ]--Leave SqQueue Normal
[2023-5]--[ Debug ]--Enter SqQueue Normal
[2023-5]--[ Debug ]--Enter SqQueue Normal
[2023-5]--[ Debug ]--SqQueue Data   :
Data           : [ 1 ,3 ]
FrontIndex     : 1
RearIndex      : 3
SqQueueLen     : 2
Flag           : INT_TYPE_FLAG
[2023-5]--[ Debug ]--Leave SqQueue Normal
[2023-5]--[ Debug ]--Enter SqQueue Normal
[2023-5]--[ Debug ]--SqQueue Data   :
Data           : [ 3 ,0 ]
FrontIndex     : 2
RearIndex      : 4
SqQueueLen     : 2
Flag           : INT_TYPE_FLAG
[2023-5]--[ Debug ]--Leave SqQueue Normal
[2023-5]--[ Debug ]--Enter SqQueue Normal
[2023-5]--[ Debug ]--Destroy SqQueue Normal
[2023-5]--[ Debug ]--Breadth First Search Use AMGraph OK
[2023-5]--[ Debug ]--Traverse Use AMGraph               : [4 ,1 ,3 ,0 ,2 ]
[2023-5]--[ Debug ]--Init SqQueue Normal
[2023-5]--[ Debug ]--Enter SqQueue Normal
[2023-5]--[ Debug ]--Leave SqQueue Normal
[2023-5]--[ Debug ]--Enter SqQueue Normal
[2023-5]--[ Debug ]--Enter SqQueue Normal
[2023-5]--[ Debug ]--Leave SqQueue Normal
[2023-5]--[ Debug ]--Enter SqQueue Normal
[2023-5]--[ Debug ]--Enter SqQueue Normal
[2023-5]--[ Debug ]--Destroy SqQueue Normal
[2023-5]--[ Debug ]--Breadth First Search Use AGraph OK
[2023-5]--[ Debug ]--Traverse Use AGraph                : [4 ,3 ,1 ,2 ,0 ]
[2023-5]--[ Info  ]--Destory Net Data                   : OK
[2023-5]--[ Info  ]--Destory Undirection Net Use AMGraph: OK
[2023-5]--[ Info  ]--Destory Undirection Net Use AGraph : OK

阳光九叶草LXGZXJ
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构图bfs，Dfs遍历算法
12-09
数据结构预算法上机作业 图 深度遍历广度遍历
图的遍历方法——DFS和BFS
syh的技术记录
05-18 4854
DFS类似于树的先序遍历，因此可以用递归实现； BFS类似于树的层次遍历，因此可以用队列实现。 说明：下面代码中图的存储方式是邻接表。关于邻接表和邻接矩阵可看邻接表和邻接矩阵 1.深度优先遍历（ Depth First Search） 思想 从图中的某一个顶点 v0 出发，访问此顶点，然后依次从 v0 的没被访问的邻接点出发深度优先遍历图（体现了递归的思想），直至图中所有和 v0 有路径相通的顶点都被访问到；若此时图中仍有结点没有被访问，则另选图中一个未曾访问的顶点作起始点，重复上述过程。 因为要
BFS (Breadth-First Search)：广度优先搜索和DFS (Depth-First Search)：深度优先搜
04-11
在计算机科学中，搜索算法是用来在图或树结构中寻找从起点到目标点的路径的算法。其中，广度优先搜索（Breadth-First Search，简称BFS）和深度优先搜索（Depth-First Search，简称DFS）是两种最基本且广泛使用的图遍历算法。 广度优先搜索（BFS）是一种按层次遍历图的算法。它从图的某个顶点开始，首先访问所有邻近的顶点，然后对这些邻近顶点的未访问邻居进行访问，以此类推，直到访问完所有可达的顶点。BFS的特点是从接近起点的节点开始，逐步向外扩展，因此它能够找到最短路径。BFS适用于解决无权图中的最短路径问题，或者在搜索空间较大时，需要快速找到一个解决方案的场景。 BFS的实现通常使用队列数据结构。算法开始时，将起点加入队列。然后，进入循环，在每次迭代中从队列中取出一个顶点，访问它的所有未访问邻居，并将这些邻居加入队列。这个过程一直持续到队列为空，即所有可达顶点都被访问过。 深度优先搜索（DFS）则是一种深入搜索图的算法。它从图的某个顶点开始，尽可能深地搜索每一个分支，当节点v的某条分支被追踪到终点或无法继续前进时，算法回溯到节点v的上一个节点，
数据结构深度、广度优先搜索算法C语言版
05-20
数据结构课程中的深度优先搜索算法、广度优先搜索算法的C语言程序，在Turbo C 2.0上调试通过。
C#，深度优先搜索（DFS）、广度优先搜索（BFS）算法的源代码与数据可视化
03-18
深度优先搜索（亦称深度优先遍历，Deep First Search，简称DFS），广度优先搜索（亦称广度优先遍历，Breadth First Search，简称BFS）都是很基础的算法，也是大家很熟悉的。算法，又叫宽度优先遍历，或横向优先遍历，是从根节点开始，沿着树的宽度遍历树的节点。如果所有节点均被访问，则算法中止。 深度优先遍历算法是遍历算法的一种。是沿着树的深度遍历树的节点。 当节点v的所有边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。 如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。
图的遍历（详解DFS与BFS）
CXR_XC的博客
11-11 8333
详解DFS和BFS的方法和具体实现，包括邻接矩阵和邻接表两种数据结构
C++数据结构之图的遍历——DFS和BFS（带有gif演示）
m0_56398315的博客
08-19 5770
本文介绍了继图的存储结构之后对图进行遍历，分为DFS和BFS两种算法，赋有动态gif图示和相关代码以及注释
数据结构 --- 图的遍历 DFS、BFS
weixin_60569662的博客
04-03 3559
什么是DFS、BFS？ 一条线走到底，深度优先遍历，每一个顶点只遍历、只打印一次的方式：DFS、BFS 数据结构 --- 图的存储_考拉爱睡觉鸭~的博客-CSDN博客 单纯地把邻接顶点的邻接顶点打印出来，顶点重复遍历，打印多次 从 A→F 所有的节点都遍历完了，需要做回退，从F回退到D点，找D点有没有邻接顶点，没有邻接顶点，继续做回退，退到B节点，有未访问的临接顶点，访问C顶点 如果遍历的节点已经被遍历了，不能重复遍历，要做回退 如果形成环状，也是重复遍历的情况，也要做回.........
【数据结构基础】图 - 遍历(BFS & DFS)
DeveloperFire的博客
02-06 1736
它的思想: 假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和v有路径相通的顶点都被访问到。若此时尚有其他顶点未被访问到，则另选一个未被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。显然，深度优先搜索是一个递归的过程。广度优先搜索算法(Breadth First Search)，又称为"宽度优先搜索"或"横向优先搜索"，简称BFS。
浅浅认识DFS与BFS
m0_72386103的博客
04-07 725
BFS与DFS分别在什么场景下使用
vistra:算法和数据结构可视化
05-19
可视化算法和数据结构 桌面应用程序，用于图形算法的可视化，实现时要考虑设计原理和设计模式。 算法：深度优先搜索DFS，广度优先搜索BFS，Dijkstra，Kruskal。 方法：面向对象的分析与设计OOAD，面向对象的编程OOP。 技术：Oracle Java，带有Apache Maven和Ant的Eclipse项目，Java Swing UI框架，Apache Commons IO，net.datastructures，Java通用网络/图形框架JUNG，GraphML。 ，，， 。 解决方案 框架： 封装图，实现的设计模式， ， ， 打包算法，已实施的设计模式 程序包遍历，实现了设计模式 应用： 实现为 算法：BFS， DFS ， Dijkstra ，Kruskal 模块项目1，学期论文HS 2013/14。 伯尔尼应用科学大学，技术与计算机科学系BFH-TI，比尔/比
AI-Search-Algorithms:该项目在ex的给定图中考虑了以下不知情的图搜索算法。 广度优先搜索（BFS），深度优先搜索（DFS），迭代加深搜索（IDS），统一成本搜索（UCS）（Dijkstra算法）和A *算法（A星）
03-12
人工智能搜索算法 图搜索算法在AI中很重要。 该项目考虑了给定图中的以下不知情的图搜索算法。 广度优先搜索（BFS） 深度优先搜索（DFS） 迭代深化搜索（IDS） 统一成本搜索（UCS）（Dijkstra算法） A *算法（A星） 我实现了上述算法，以找到任何给定图（状态空间图）的遍历路径和精确路径。 状态空间图可以表示为搜索树。 起始状态是根节点，子级对应于后续级。 表示图形有两种流行的选择：邻接矩阵和邻接表。 您可以使用以下两个选项之一插入给定的图形。 对于较小的图形表示，使用邻接表很容易。 然后，在随机生成的空间图的第一部分中实现算法。 （bfs-random，dfs-random，ucs-random等）
图Graph, 深度优先遍历(DFS), 广度优先遍历(BFS)【数据结构和算法入门9】
08-30
图Graph,_深度优先遍历(DFS),_广度优先遍历(BFS)【数据结构和算法入门9】
ACM算法设计-BFS-DFS详解_算法_dfs_ACM_zoouts_bfs_
10-01
对bfs（广度优先遍历）和dfs（深度优先遍历）的详细解析，帮助人们理解广搜和深搜
图的深度、广度优先遍历
06-02
/*---------------------------------------------------------------------------------------------------*/ /*图的深度优先遍历搜索递归算法。g为存储图的邻接表，i为遍历的初始顶点编号， */ void dfs(ALGraph *g,int i) { ArcNode *p = NULL; printf("%d\t", g -> adjlist[i].data); visited[i] = 1; p = g -> adjlist[i].firstarc; while( p != NULL) { if(visited[p -> adjvex] == 0) { dfs(g, p-> adjvex); } p = p -> nextarc; } }
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 4886
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
数据结构——树和二叉树的基本概念
最新发布
qq_67693066的博客
04-24 1073
数据结构——树和二叉树的基本概念
数据结构中的栈和队列（附实际案例代码）
JAZJD的博客
04-23 792
栈（Stack）和队列（Queue）
数据结构——堆
2301_76613753的博客
04-20 1562
之前我们了解到了一种非线性的数据结构——树，今天我们来学习二叉树的顺序结构——堆的实现，来了解堆这种数据结构。一、堆的概念及结构如果有一个关键码的集合K = { ， ， ，…， }，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足： <=且 <=( >=且 >= ) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。堆的性质：堆中某个节点的值总是不大于或不小于其父节点的值；堆总是一棵完全二叉树。
图的遍历（搜索）算法（深度优先算法DFS和广度优先算法BFS）
05-30
好的，关于图的遍历算法，我可以为您简要介绍一下。 图是由节点和边组成的一种数据结构，其中节点表示实体，边表示节点之间的关系。遍历图的目的是访问图中的每个节点，以便了解它们之间的关系。 深度优先算法（DFS）是一种递归算法，它从起点开始沿着一条路径一直遍历到底，直到无法继续为止，然后回溯到前一个节点并选择另一条路径继续遍历。这个过程一直持续到所有节点都被访问为止。DFS的时间复杂度为O(V+E)，其中V表示节点数，E表示边数。 广度优先算法（BFS）是一种迭代算法，它从起点开始，首先访问与起点相邻的所有节点，然后依次访问与这些节点相邻的未访问节点，直到所有节点都被访问为止。BFS使用队列来存储待访问的节点，先进先出。BFS的时间复杂度为O(V+E)。 这就是关于图的遍历算法的简单介绍，希望能对您有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值