【算法】基于邻接链表的图的遍历BFS(非递归)&DFS(递归/非递归)代码实现

最新推荐文章于 2022-03-19 14:54:18 发布
置顶 最新推荐文章于 2022-03-19 14:54:18 发布
阅读量529 收藏 6
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 dfs bfs 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41139677/article/details/108905016
版权

C/C++代码实现

main.cpp
/****************************************************************
C语言实现--邻接链表实现图的创建 遍历 DFS & BFS 递归及非递归方法
*****************************************************************/
#define INF 65535
#define MAX_VERTEX_NUM 20 //最大顶点个数
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"SqStack.h"
#include"SqQueue.h"

typedef int VertexType;
typedef int InfoType;
typedef int AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef enum {
    DG,//有向图
    DN,//有向网
    UDG,//无向图
    UDN//无向网
} GraphKind;

typedef struct ArcNode {
    int adjvex;             //该弧指向的顶点的位置
    struct ArcNode* nextarc;//指向下一条弧的指针
    InfoType info;         //该弧的相关信息
}ArcNode;

typedef struct VNode {
    VertexType data;//顶点信息
    ArcNode* firstarc;//指向第一条依附该顶点的弧的指针
}VNode, AdjList[MAX_VERTEX_NUM];

typedef struct {
    AdjList vertices;
    int vexnum, arcnum;//图的顶点数 和 弧数
    int kind;//图的种类
}ALGraph;
int vis[MAX_VERTEX_NUM];

/*定位元素的位置*/
int LocateVertex(ALGraph& G, VertexType v)
{
    for (int i = 0; i < G.vexnum; i++)
    {
        if (G.vertices[i].data == v)
            return i;
    }
    return -1;
}

/*创建有向图*/
void CreateDG(ALGraph &G)
{
	ArcNode* p;
	for (int i = 0; i < G.vexnum; i++)
	{
		G.vertices[i].data = i + 1;
		G.vertices[i].firstarc = NULL;
	}

	for (int k = 0; k < G.arcnum; k++)
	{
		VertexType v1, v2;
		scanf("%d%d", &v1, &v2);
		int i = LocateVertex(G, v1);
		int j = LocateVertex(G, v2);
		/*j为入i为出创建邻接链表*/
		//p = new ArcNode;
		p = (ArcNode*)malloc(sizeof(ArcNode));
		p->adjvex = j + 1;
		p->nextarc = G.vertices[i].firstarc;
		G.vertices[i].firstarc = p;
	}
}
/*创建有向网*/
void CreateDN(ALGraph &G)
{
	ArcNode* p;
	for (int i = 0; i < G.vexnum; i++)
	{
		G.vertices[i].data = i + 1;
		G.vertices[i].firstarc = NULL;
	}


	for (int k = 0; k < G.arcnum; k++)
	{
		VertexType v1, v2;
		int w;
		scanf("%d%d%d", &v1, &v2, &w);
		int i = LocateVertex(G, v1);
		int j = LocateVertex(G, v2);
		/*j为入i为出创建邻接链表*/
		//p = new ArcNode;
		p = (ArcNode*)malloc(sizeof(ArcNode));
		p->adjvex = j + 1;
		p->info = w;
		p->nextarc = G.vertices[i].firstarc;
		G.vertices[i].firstarc = p;
	}
}
/*创建无向图*/
void CreateUDG(ALGraph &G)
{
	ArcNode* p;
	for (int i = 0; i < G.vexnum; i++)
	{
		G.vertices[i].data = i + 1;
		G.vertices[i].firstarc = NULL;
	}

	for (int k = 0; k < G.arcnum; k++)
	{
		VertexType v1, v2;
		scanf("%d%d", &v1, &v2);
		int i = LocateVertex(G, v1);
		int j = LocateVertex(G, v2);
		/*j为入i为出创建邻接链表*/
		//p = new ArcNode;
		p = (ArcNode*)malloc(sizeof(ArcNode));
		p->adjvex = j + 1;
		p->nextarc = G.vertices[i].firstarc;
		G.vertices[i].firstarc = p;
		/*i为入j为出创建邻接链表*/
		//p = new ArcNode;
		p = (ArcNode*)malloc(sizeof(ArcNode));
		p->adjvex = i + 1;
		p->nextarc = G.vertices[j].firstarc;
		G.vertices[j].firstarc = p;
	}
}
/*创建无向网*/
void CreateUDN(ALGraph &G)
{
	ArcNode* p;
	for (int i = 0; i < G.vexnum; i++)
	{
		G.vertices[i].data = i + 1;
		G.vertices[i].firstarc = NULL;
	}

	for (int k = 0; k < G.arcnum; k++)
	{
		VertexType v1, v2;
		int w;
		scanf("%d%d%d", &v1, &v2, &w);
		int i = LocateVertex(G, v1);
		int j = LocateVertex(G, v2);
		/*j为入i为出创建邻接链表*/
		//p = new ArcNode;
		p = (ArcNode*)malloc(sizeof(ArcNode));
		p->adjvex = j + 1;
		p->info = w;
		p->nextarc = G.vertices[i].firstarc;
		G.vertices[i].firstarc = p;
		/*i为入j为出创建邻接链表*/
		//p = new ArcNode;
		p = (ArcNode*)malloc(sizeof(ArcNode));
		p->adjvex = i + 1;
		p->info = w;
		p->nextarc = G.vertices[j].firstarc;
		G.vertices[j].firstarc = p;
	}
}
/*打印图的邻接链表*/
void DisplayALGraph(ALGraph &G)
{
	ArcNode* p;
	for (int i = 0; i < G.vexnum; i++)
	{
		printf("%d-->", G.vertices[i].data);
		p = G.vertices[i].firstarc;
		if (p == NULL)
			printf("NULL");
		while (p)
		{
			if (G.kind == 1 || G.kind == 3)
				printf("%d ", p->adjvex);
			else if (G.kind == 2 || G.kind == 4)
				printf("%d,%d ", p->adjvex, p->info);
			p = p->nextarc;
		}
		printf("\n");
	}
}
/*
递归深度优先遍历
函数功能：DFS递归遍历图（邻接表）
函数说明：建立一个标记数组vis[], 若该顶点访问过就标记为1，否则置零；
递归的时候，从某个指定定点开始进行，遍历第一个邻接点，然后再遍历
邻接点的第一个邻接点......直到某个顶点没有未访问的邻接点，就退
出该层递归，然后再进入上一层递归，直到所有的顶点都没有未访问的顶点
dfs遍历结束。每一次大的for循环结束就找到了一个连通子集。
*/
void DFSRecursiveTraverse(ALGraph& G, int i)
{
	printf("%d ",G.vertices[i].data);//输出顶点值
	ArcNode* p = G.vertices[i].firstarc; //指向第一个邻接顶点
	vis[i] = 1; //v已经访问过了

	while (p)
	{
		VertexType u = p->adjvex - 1;//顶点序号
		if (!vis[u])//没访问过
		{
			DFSRecursiveTraverse(G, u);//从该节点的邻接点出发继续深度优先遍历
		}
		p = p->nextarc;//从某顶点出发深度优先遍历结束了 回溯到上一个顶点p 指向上一个节点的其他邻接点
	}
}

/*
非递归DFS遍历图
压栈的顺序就是深度优先遍历的顺序
3
8
9

1 2
1 3
2 4
2 5
3 6
3 7
4 8
5 8
6 7
*/
void DFSNonrecursiveTraverse(ALGraph &G, int i){
    vis[i] = 1;//该顶点已经访问
    SqStack S;
    InitStack(S);
    Push(S, G.vertices[i].data);//将顶点压栈
    //printf("%d ",G.vertices[i].data);
    printf("%d 入栈\n", G.vertices[i].data);

    while(!IsEmptyS(S))
    {
        //栈不空
        VertexType e;
        GetTop(S, e);//得到栈顶元素
        int k = LocateVertex(G, e);
        ArcNode *p = G.vertices[k].firstarc;//指向第一个邻接点
        while(p)//只要有邻接点
        {
            int j = LocateVertex(G, p->adjvex);//定位顶点索引
            if(!vis[j])//该顶点没有被访问
            {
                //置访问标志
                vis[j] = 1;
                //压栈
                Push(S, G.vertices[j].data);
                printf("%d 入栈\n", G.vertices[j].data);
                //printf("%d ",G.vertices[j].data);
                p = G.vertices[j].firstarc;//指向下一顶点的第一个邻接点
            }
            else//该顶点已经被访问了
            {
                //继续访问下一个邻接点
                p = p->nextarc;
                //当某个顶点的所有邻接点都访问完之后 p就会变成NULL
            }
        }//此时退出循环
        if(p == NULL)
        {
            VertexType v;
            Pop(S, v);//将所有邻接点都访问完的顶点出栈
            printf("%d 出栈\n", v);
        }
    }

    ClearStack(S);
}


/*递归DFS遍历图*/
void DFSTraverse(ALGraph &G, int type)
{
    memset(vis, 0, sizeof(vis));//初始化为0
	for (int i = 0; i < G.vexnum; i++)
	{
		if (!vis[i] && type == 0)//递归
		{//遍历每个顶点
			DFSRecursiveTraverse(G, i);
		}

		if (!vis[i] && type == 1)//非递归
		{//遍历每个顶点
			DFSNonrecursiveTraverse(G, i);
		}
	}
}

/**************************************************************
函数功能：BFS非递归遍历图（邻接表）
函数说明：建立一个标记数组vis[],若该顶点访问过就标记为1，否则置零；
遍历的时候，首先找到一个未访问的顶点，入队，然后如果队列不空，就
一直循环，并且每次循环都要出队一个元素，再在以该元素为顶点的链表
或者矩阵的某一行中进行查找，如果某个顶点未访问，则进行访问，然后
vis置1，表示已经访问，再入队，直到队为空，退出本次循环，再查找顶
点表中的第二个顶点或者矩阵中的第二行，以此类推得到广度优先搜索序
列，每次大的循环其实就是一个连通子集。
***************************************************************/
void BFS(ALGraph &G, int i)
{
    vis[i] = 1;
    SqQueue Q;
    InitQueue(Q);
    EnQueue(Q, G.vertices[i].data);//入队
    printf("%d 入队\n", G.vertices[i].data);

    while(!IsEmptyQ(Q))
    {
        VertexType e;
        DeQueue(Q, e);
        printf("%d 出队\n", e);
        int k = LocateVertex(G, e);
        ArcNode *p = G.vertices[k].firstarc;
        while(p)
        {
            int j = LocateVertex(G, p->adjvex);
            if(!vis[j])
            {
                vis[j] = 1;//访问过了
                //入队
                EnQueue(Q, G.vertices[j].data);
                printf("%d 入队\n",G.vertices[j].data);
            }
            p = p->nextarc;
        }
    }

    ClearQueue(Q);
}

/*入队序列就是BFS遍历结果*/
void BFSTraverse(ALGraph &G)
{
    memset(vis, 0, sizeof(vis));//初始化为0

	for (int i = 0; i < G.vexnum; i++)
    {
        if(!vis[i])
        {
            BFS(G, i);
        }
    }
}




/*根据图的种类创建图*/
void CreateGraph(ALGraph &G)
{
    printf("请输入图的种类(1-有向图, 2-有向网, 3-无向图, 4-无向网)：");
    scanf("%d", &G.kind);
    printf("请输入创建图的顶点数：");
    scanf("%d", &G.vexnum);
    printf("请输入创建的图的边/弧数：");
    scanf("%d", &G.arcnum);

    printf("请输入弧依附的顶点信息:\n");
    switch (G.kind)
    {
    case 1: //DG
        CreateDG(G);
        break;
    case 2: //DN
        CreateDN(G);
        break;
    case 3: //UDG
        CreateUDG(G);
        break;
    case 4: //UDN
        CreateUDN(G);
        break;
    }
}

int main() {
	ALGraph G;
	CreateGraph(G);
	DisplayALGraph(G);
	printf("DFS递归遍历结果:");
	DFSTraverse(G, 0);
	printf("\n");
	printf("DFS非递归遍历结果:\n");
	DFSTraverse(G, 1);
    printf("\n");
    printf("BFS非递归遍历结果:\n");
    BFSTraverse(G);
    printf("\n");
	return 0;
}
SqQueue.h
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define QUEUE_INIT_SIZE 100
#define OVERFLOW -2

typedef int Status;
typedef int QElemType;

typedef struct
{
    QElemType* base;
    int   front;
    int   rear;
} SqQueue; //顺序表实现队列 非循环队列

Status InitQueue(SqQueue& Q);
Status EnQueue(SqQueue& Q, QElemType e);
Status DeQueue(SqQueue& Q, QElemType& e);
Status IsEmptyQ(SqQueue& Q);
Status GetFront(SqQueue& Q, QElemType& e);
void ClearQueue(SqQueue &Q);
SqQueue.cpp
#include<stdio.h>
#include<stdlib.h>
#include"SqQueue.h"

Status InitQueue(SqQueue& Q)
{
    Q.base = (QElemType*)malloc(sizeof(QElemType) * QUEUE_INIT_SIZE);
    if (!Q.base) exit(OVERFLOW);
    Q.front = Q.rear = 0;
    return OK;
}

Status EnQueue(SqQueue& Q, QElemType e)
{
    Q.base[Q.rear] = e;
    Q.rear = Q.rear + 1;
    //循环队列
    //Q.rear = (Q.rear + 1)%(QUEUE_INIT_SIZE + 1);
    return OK;
}

Status DeQueue(SqQueue& Q, QElemType& e)
{
    if (Q.front == Q.rear)
    {
        return ERROR;
    }
    e = Q.base[Q.front];
    //循环队列
    //Q.front = (Q.front + 1) % (QUEUE_INIT_SIZE + 1);
    Q.front = Q.front + 1;

    return OK;
}

Status IsEmptyQ(SqQueue& Q)
{
    if (Q.front == Q.rear) return TRUE;
    return FALSE;
}

Status GetFront(SqQueue& Q, QElemType& e)
{
    if (Q.front == Q.rear)
        return ERROR;
    e = Q.base[Q.front];
    return OK;
}

void ClearQueue(SqQueue &Q)
{
    free(Q.base);
    Q.base = NULL;
    Q.front = Q.rear;
}
SqStack.h
#define ERROR 0
#define OK 1
#define TRUE 1
#define FALSE 0
#define STACK_INIT_SIZE 100
#define STACK_INCREMENT 10
#define OVERFLOW -2

typedef int SElemType;
typedef int Status;

typedef struct
{
    SElemType* base;
    SElemType* top;
    int stacksize;
} SqStack;

Status InitStack(SqStack& S);
Status GetTop(SqStack& S, SElemType& e);
Status Push(SqStack& S, SElemType e);
Status Pop(SqStack& S, SElemType& e);
Status IsEmptyS(SqStack& S);
void ClearStack(SqStack& S);
SqStack.cpp
#include"SqStack.h"
#include<stdio.h>
#include<stdlib.h>

Status InitStack(SqStack& S)
{
    S.base = (SElemType*)malloc(sizeof(SElemType) * STACK_INIT_SIZE);//构造空栈
    if (!S.base) exit(OVERFLOW);
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    return OK;
}

Status GetTop(SqStack& S, SElemType& e)
{
    if (S.top == S.base)
    {
        return ERROR;
    }
    e = *(S.top - 1);
    return OK;
}

Status Push(SqStack& S, SElemType e)
{
    if (S.top - S.base >= S.stacksize)//栈满
    {
        S.base = (SElemType*)realloc(S.base, (S.stacksize + STACK_INCREMENT)
            * sizeof(SElemType));
        if (!S.base) exit(OVERFLOW);

        S.top = S.base + S.stacksize;//调整栈顶指针
        S.stacksize += STACK_INCREMENT;//改变了
    }
    *S.top++ = e;

    return OK;
}

Status Pop(SqStack& S, SElemType& e)
{
    //判断栈是否为空
    if (S.top == S.base) return ERROR;
    e = *--S.top;
    return OK;
}

Status IsEmptyS(SqStack& S)
{
    if (S.base == S.top)
        return TRUE;
    return FALSE;
}

void ClearStack(SqStack& S)
{
    free(S.base);
    S.base = NULL;
    S.top = S.base;
}
Articoder
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构17：邻接表及其广度遍历
qq_70132617的博客
05-30 632
摘要： 邻接表是图的链式压缩存储，即我们只记录这个结点与哪些结点连通，没有连通的就不予记录。有N个结点就要用N个链表来存储他们的连通关系。 一.代码块 由于我们写的代码是由之前的二维数组图结构转化为邻接表结构，所以之前写的代码很大一部分用得上，我们先copy过来 1）copy代码 #define MAXSIZE 10 int* visited; typedef struct graph { int** connections; int numNodes; }*graphPtr; typedef
图的邻接链表存储，递归的深度优先遍历和非递归的广度优先遍历
R1NR1N的博客
06-01 1201
题目：要求图用邻接表方式存储，输入一个图，进行图的深度优先遍历及广度优先遍历。 #include <stdio.h> #include <stdlib.h> #define MAX 50 FILE *fp; typedef struct Edgenode { int data; struct Edgenode *next; } Edgenode; struct Linjienode { int visit; Edgenode *tounode; } L
用邻接表储存结构实现图的（非）递归（广）深度遍历（C++
qq_46354688的博客
05-22 1469
用邻接表储存结构实现图的（非）递归（广）深度遍历（C++）图的定义，建立与打印顶点、弧、图的结构体弧结点顶点结点图结构体图的建立打印邻接表图的遍历非递归深度优先遍历递归实现深度优先遍历非递归实现广度优先遍历图的简单应用非递归广度优先遍历查找是否存在v1到v2的路径递归深度优先遍历查找v1到v2是否存在长度为k的简单路径主函数 叽里呱啦：笔者是一名程序员萌新，所写的代码可能会有很多很多方面的不足，欢迎一起交流。 此篇文章是笔者在CSDN上的第一篇，对排版方面没有什么经验，内容有不足的地方欢迎指正 本实验效
c++ 数据结构 图的应用（实现图的深度优先和广度优先遍历）——以邻接表为存储结构
Arana的博客
04-06 1万+
数据结构实习——图及应用（图的遍历） 一、问题描述 很多涉及图上操作的算法都是以图的遍历操作为基础的。试写一个程序，演示无向图的遍历操作。 二、基本要求 以邻接表为存储结构，实现连通无向图的深度优先和广度优先遍历。以用户指定的结点为起点，分别输出每种遍历下的结点访问序列和相应生成树的边集。 三、实现提示 设图的结点不超过30个，每个结点用一个编号表示（如果一个图有n个结点，则它们的编号分别为1，2...
邻接表存储图的深度优先、广度优先遍历非递归算法
yk_ee的博客
06-17 7422
邻接表存储图的深度、广度优先非递归遍历
图的非递归深度遍历以及广度遍历（已免费下载）
12-06
在实验中，你需要编写基于这两种存储结构的图创建算法，以及对应的非递归遍历算法。对于邻接矩阵，你可以使用上述的DFS和BFS算法框架，只需将节点的邻居信息替换为邻接矩阵的对应位置。对于邻接链表，遍历过程中需要...
C语言：图的DFS和BFS（内附代码和算法思路）.docx
11-01
在本文档中，我们讨论了如何使用C语言实现无向图的深度优先遍历（DFS）和广度优先遍历（BFS）。首先，我们需要理解数据结构中的图，它由顶点（vertices）和边（edges）组成，无向图意味着边没有方向。图的存储通常有...
邻接链表存储的有向图
07-13
1.生成一个100个点，3000条边的有向随机图，任选一点作为源点，计算S到其他节点的距离。（注：图用邻接链表存储） 2.将实验一中的有向图变为DAG图。（从中去掉一些边，不允许用递归） 计算上述DAG图中的最长路径。
图的邻接矩阵、邻接表和遍历参考.pdf
12-04
`dfsl`和`bfsl`函数与邻接矩阵的情况类似，实现了基于邻接表的DFS和BFS遍历。 深度优先搜索在邻接表中实现时，通常从当前节点的链表开始，对每个未访问的相邻节点递归调用DFS。广度优先搜索使用队列来存储待访问的...
第二讲：复习专题之链表,指针,dfs&bfs.pptx
10-05
DFS通常使用递归或栈实现，先访问当前节点，然后遍历其所有未访问的邻接节点。BFS则使用队列，先访问离起点最近的节点，然后依次访问相邻节点。 例如，在题目1中，我们使用了数组和结构体来存储学生信息，然后通过...
邻接表实现DFS和BFS
Missjust的博客
11-29 1646
题目 用邻接表存储下图 ，并实现BFS和DFS。 解题思路 这是一个带权无向图，题目要求用一个邻接表存储，可以是一个链表数组，但本题采用C++STL中的multimap实现。把一个char字符与一个结构体节点进行映射，形成多个映射。每个结构体节点包括一个char类型的数据和一个int类型的权。这里采用char字符是为了使节点更加常规化。 再采用BFS和DFS对该表从0节点开始做一个遍历，思路也比...
图的深度/广度优先遍历DFS和BFS（邻接表实现）c语言
热门推荐
大芝士球的博客
02-08 3万+
目录 定义 邻接表存储图 深度优先遍历 广度优先遍历： BFS部分 完整代码 定义 要实现该算法首先要知道邻接表的概念。 邻接表是一种常用的图的存储结构，它的结构特点是： 顶点由一个一维数组存储； 邻接点用链表存储 相比于单纯用数组实现的邻接矩阵，邻接表可以避免空间浪费 其图解如下： firstedge指向边表第一个结点。 边表的adjvex的值代表与V0顶...
C语言无向图的邻接表储存以及DFS、BFS的实现
weixin_45883188的博客
07-15 1650
代码实现内容: ①无向图的邻接表储存 ②基于此存储结构的DFS BFS /* 实现内容: ①无向图的邻接表储存实现 ②DFS BFS 邻接表：顶点结构顺序存储(结构数组) 结构包含顶点信息和从该顶点出去的第一个弧节点指针 弧节点包括：下一个弧节点指针、弧依附的另一个顶点在数组的下标、弧的信息(ex:权重) 由于邻接表存储方式的问题，在DFS时想要左边先遍历，必须要在给边标号的时候，对于同一个顶点， 右侧边的序号大于左侧边的序号 VS2019编译通过 2020.7.15 王大花 */ #
图的邻接表存储及DFS，BFS遍历
zhangjc9401的专栏
02-03 728
每天进步一小步~
C++类 接邻表实现图的BFS与DFS遍历
Rice__的博客
11-16 216
图:用list表示接邻表链 BFS:容器与队列 DFS:递归/涂色法 用例 5 1 2 1 1 3 1 1 5 1 2 3 1 2 4 1 3 5 1 4 5 1 0 0 0 结果 BFS遍历如下: 访问结点 1(父结点:0,距离:0) 访问结点 2(父结点:1,距离:1) 访问结点 3(父结点:1,距离:1) 访问结点 5(父结点:1,距离:1) 访问结点 4(父结点:2,距离:2) DF...
用邻接表表示图的BFS，DFS遍历
qq_43271509的博客
03-19 835
BFS #include <stdio.h> #include<stdlib.h> #define MaxVertexNum 10 /* 最大顶点数设为10 */ typedef int Vertex; /* 用顶点下标表示顶点,为整型 */ /* 邻接点的定义 */ typedef struct AdjVNode *PtrToAdjVNode; struct AdjVNode{ Vertex AdjV; /* 邻接点下标 */ Pt
c语言对于图的存储（领接矩阵）及遍历（DFS,BFS）
baldicoot_的博客
11-20 792
这里介绍用邻接矩阵存储无序图，以及利用深度遍历和广度遍历对存储的图进行遍历。详细步骤会进行注释解析。 #include <stdio.h> #define MAX 20 typedef int Vertex; Vertex visit[MAX] = { 0 }; //定义两个全局数组，在遍历时用于判读该点是否已...
图的遍历(C语言,邻接表存储的图 - DFS,邻接矩阵存储的图 - BFS)
m0_51955470的博客
11-17 324
邻接表存储的图 - DFS /* 邻接表存储的图 - DFS */ void Visit( Vertex V ) { printf("正在访问顶点%d\n", V); } /* Visited[]为全局变量，已经初始化为false */ void DFS( LGraph Graph, Vertex V, void (*Visit)(Vertex) ) { /* 以V为出发点对邻接表存储的图Graph进行DFS搜索 */ PtrToAdjVNode W; Visit(
图的dfs递归(非递归)遍历和bfs遍历(邻接表)
杨龙飞的博客
03-12 2739
1.深度优先遍历是连通图的一种遍历策略．其基本思想如下: 设x是当前被访问的顶点，在对x做过访问的标记之后，选择一条从x出发的未检测过的边(x,y),若发现顶点y已经访问过了，则重新选择另一条从x出发的未检测过的边，否则沿边(x,y)到达未曾访问过的y，对y访问并将其标记为已访问过,然后从y开始搜索,直到搜索完从y出发的所有路径,即访问完所有从y出发可达的顶点之后，才回溯到顶点x,并且再选择
邻接矩阵非递归深度遍历和邻接链表非递归层次遍历
最新发布
11-13
以下是邻接矩阵非递归深度遍历和邻接链表非递归层次遍历的Python实现： 邻接矩阵非递归深度遍历： ```python def DFS_iterative(graph, start): visited = set() # 用集合存储已访问的节点 stack = [start] # 用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值