深度、广度优先搜索

最新推荐文章于 2022-07-15 14:44:22 发布
最新推荐文章于 2022-07-15 14:44:22 发布
阅读量164 收藏
点赞数
分类专栏： # 数据结构与算法 文章标签： dfs bfs 图的遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46672746/article/details/118097444
版权

文章目录

二、图的遍历

2.1 深度优先搜索（DFS）

DFS森林

Vertextype GetVex(ALGraph G, int v)
{
    return G.vertices[v].data;
}

void DFSTree(ALGraph G, int v, CSTree& T)
{
    int w, first;
    CSTree p, q=NULL;
    ArcNode* temp;
    visited[v] = TRUE;
    first = 1;
    temp = G.vertices[v].firstarc;
    while (temp != NULL)
    {
        w = temp->adjvex;
        if (visited[w] == 0)
        {
            p = (CSTree)malloc(sizeof(CSNode));
            p->e = GetVex(G, w);  //原"GetVex(G,v)";将v改为w即可
            p->lchild = NULL;
            p->nextsibling = NULL;
            if (first)
            {
                T->lchild = p; first = 0;
            }
            else
                q->nextsibling = p;
            q = p;
            DFSTree(G, w, q);
        }
        temp = temp->nextarc;
    }
}

void DFSForest(ALGraph G, CSTree& T)
{
    int v;
    CSTree p, q=NULL;
    T = NULL;
    for (v = 0; v < G.vexnum; v++)
        visited[v] = FALSE;
    for (v = 0; v < G.vexnum; v++)
    {
        if (!visited[v])
        {
            p = (CSTree)malloc(sizeof(CSNode));
            p->e = GetVex(G, v);
            p->lchild = NULL;
            p->nextsibling = NULL;
            if (!T) T = p;
            else    q->nextsibling = p;
            q = p;
            DFSTree(G, v, p);
        }
    }
}

应用

建立一无向图的邻接表存储结构，并构造其对应的深度优先搜索生成树或森林，按先序遍历该二叉链表，输出得到的序列

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

#define TRUE 1                /*状态码预定义*/
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

#define MAX_VERTAX_NUM 20 //最大顶点个数
typedef char Vertextype;
//邻接表类型 
typedef struct ArcNode {
    int adjvex; //邻接点域 
    struct ArcNode* nextarc; //指向下一个邻接点的指针域 
}ArcNode;
//表头结点类型 
typedef struct VNode
{
    Vertextype data; //顶点域 
    ArcNode* firstarc; //边表头指针 
}VNode, AdjList[MAX_VERTAX_NUM];
//图的类型 
typedef struct
{
    AdjList vertices; //邻接表 
    int vexnum, arcnum; //顶点数 边数 
    //int kind;
}ALGraph;
typedef struct CSNode
{
    Vertextype e;
    CSNode* lchild, * nextsibling;
}CSNode, * CSTree;
int visited[MAX_VERTAX_NUM];

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

void CreateUDG(ALGraph& G)
{
    int i, k, j;
    ArcNode* p, * s;
    char v1, v2;
//    printf("图的种类已默认为无向图\n");
//    G.kind = 1;
    printf("请输入顶点数和边数：（空格区分）");
    scanf("%d%d", &G.vexnum, &G.arcnum);
    getchar();
    printf("开始建立顶点表\n");
    for (i = 0; i < G.vexnum; i++)
    {
        printf("请输入第%d个顶点的信息:", i + 1);
        G.vertices[i].data = getchar();
        getchar();
        G.vertices[i].firstarc = NULL;
    }
    printf("建立边表\n");
    for (k = 0; k < G.arcnum; k++)
    {
        printf("请输入两个顶点（例：ab代表a~b）:");
        scanf("%c%c", &v1, &v2);
        getchar();
        i = LocateVex(G, v1);
        j = LocateVex(G, v2);
        p = (ArcNode*)malloc(sizeof(ArcNode));
        p->adjvex = j;
        p->nextarc = G.vertices[i].firstarc;
        G.vertices[i].firstarc = p;
        s = (ArcNode*)malloc(sizeof(ArcNode));
        s->adjvex = i;
        s->nextarc = G.vertices[j].firstarc;
        G.vertices[j].firstarc = s;
    }
    printf("边表建立完成\n");
}
//打印邻接表
void DispGraph(ALGraph G)
{
    int i;
    printf("打印邻接表:\n");
    for (i = 0; i < G.vexnum; i++)
    {
        printf("%d->", i);
        while (1)
        {
            if (G.vertices[i].firstarc == NULL)
            {
                printf("^");
                break;
            }
            printf("%d->", G.vertices[i].firstarc->adjvex);
            G.vertices[i].firstarc = G.vertices[i].firstarc->nextarc;
        }
        printf("\n");
    }
}

Vertextype GetVex(ALGraph G, int v)
{
    return G.vertices[v].data;
}

void DFSTree(ALGraph G, int v, CSTree& T)
{
    int w, first;
    CSTree p, q=NULL;
    ArcNode* temp;
    visited[v] = TRUE;
    first = 1;
    temp = G.vertices[v].firstarc;
    while (temp != NULL)
    {
        w = temp->adjvex;
        if (visited[w] == 0)
        {
            p = (CSTree)malloc(sizeof(CSNode));
            p->e = GetVex(G, w);  //原"GetVex(G,v)";将v改为w即可
            p->lchild = NULL;
            p->nextsibling = NULL;
            if (first)
            {
                T->lchild = p; first = 0;
            }
            else
                q->nextsibling = p;
            q = p;
            DFSTree(G, w, q);
        }
        temp = temp->nextarc;
    }
}

void DFSForest(ALGraph G, CSTree& T)
{
    int v;
    CSTree p, q=NULL;
    T = NULL;
    for (v = 0; v < G.vexnum; v++)
        visited[v] = FALSE;
    for (v = 0; v < G.vexnum; v++)
    {
        if (!visited[v])
        {
            p = (CSTree)malloc(sizeof(CSNode));
            p->e = GetVex(G, v);
            p->lchild = NULL;
            p->nextsibling = NULL;
            if (!T) T = p;
            else    q->nextsibling = p;
            q = p;
            DFSTree(G, v, p);
        }
    }
}

void PreOrderTraverse(CSTree T)
{
    if (T == NULL)   return;
    printf("%c", T->e);
    PreOrderTraverse(T->lchild);
    PreOrderTraverse(T->nextsibling);
}

int main()
{
    ALGraph G;  //图
    CSTree T;   //树
    CreateUDG(G);  //建图
    DispGraph(G);  //画表
    DFSForest(G, T);  //种树
    printf("先序遍历开始\n");
    PreOrderTraverse(T);  //先序遍历
    system("pause");
    return 0;
}

2.2 广度优先搜索（BFS）

基本操作

int FirstAdjVex(MGraph G, int v)
{
	int i;
	for (i = 0; i < G.vexnum; i++)
	{
		if (G.arcs[v][i] == 1)
			return i;
	}
	return -1;
}

int NextAdjVex(MGraph G, int u, int w)
{
	for (int i = w + 1; i < G.vexnum; i++)
	{
		if (G.arcs[u][i] == 1)
			return i;
	}
	return -1;
}
void BFSTraverse(MGraph G)
{
	SqQueue Q;
	int v, u, w, visited[MAX_VERTAX_NUM];
	for (v = 0; v < G.vexnum; ++v)
		visited[v] = FALSE;
	InitQueue(Q);
	for (v = 0; v < G.vexnum; v++)
	{
		if (!visited[v]) //尚未访问
		{
			visited[v] = TRUE; //访问并标记
			cout << G.vexs[v]; //遍历 输出
			EnQueue(Q, v); //v 入队
			while (!QueueEmpty(Q))
			{
				DeQueue(Q, u); //队头元素出队并置为u
				for (w = FirstAdjVex(G, u); w >= 0; w = NextAdjVex(G, u, w)) //遍历边
				{
					if (!visited[w])
					{
						visited[w] = TRUE;
						cout << G.vexs[w];
						EnQueue(Q, w);
					}
				}
			}
		}
	}
	cout << "广度优先搜索完成" << endl;
}

应用

#include <iostream>
using namespace std;

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1 //不可执行

#define STACK_INIT_SIZE 100 //存储空间初始分配量
#define STACKINCREMENT 10 //存储空间分配增量
#define MAXQSIZE 100 //最大队列长度

typedef int QElemType;
typedef int Status;


#define MAX_VERTAX_NUM 20 //最大顶点个数
#define INFINITYA 99999999

typedef char VertexType;
typedef int VRType;
typedef int InfoType;

typedef int AdjMatrix;
typedef int QElemtype;


/*--------单链队列-队列的顺序存储结构--------*/
/*线性表的单链表的存储结构*/
typedef struct QNode {
	QElemType* base;
	int front;
	int rear;
}SqQueue;


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

int QueueLength(SqQueue Q) {
	return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
}

/*插入元素e为Q的新的队尾元素*/
Status EnQueue(SqQueue& Q, QElemType e) {
	if ((Q.rear + 1) % MAXQSIZE == Q.front)
		return ERROR;
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear + 1) % MAXQSIZE;
	return OK;
}

/*若队列不为空则删除Q的队头元素，用e返回其值，并返回ok；否则返回ERROR*/
Status DeQueue(SqQueue& Q, QElemType& e) {
	if (Q.front == Q.rear)
		return ERROR;
	e = Q.base[Q.front];
	Q.front = (Q.front + 1) % MAXQSIZE;
	return OK;
}
/*判断队列是否为空*/
Status QueueEmpty(SqQueue Q) {
	if (Q.front == Q.rear)
		return TRUE;
	else
		return FALSE;
}


//邻接矩阵
typedef struct
{
	VertexType vexs[MAX_VERTAX_NUM];
	AdjMatrix arcs[MAX_VERTAX_NUM][MAX_VERTAX_NUM];
	int vexnum, arcnum;
}MGraph;

int LocateVex(MGraph G, VertexType e)
{
	int i;
	for (i = 0; i < G.vexnum; i++)
	{
		if (G.vexs[i] == e)
			return i;
	}
	return -1;
}

Status CreateDG(MGraph& G)
{
	int i, j, k;
	char v1, v2;
	cout << "请输入图的顶点个数（vexnum），边数（arcnum）";
	cin >> G.vexnum >> G.arcnum;
	getchar();
	cout << "请输入顶点（例：abcd）:";
	for (i = 0; i < G.vexnum; i++)
		G.vexs[i] = getchar();
	getchar();

	for (i = 0; i < G.vexnum; i++)
		for (j = 0; j < G.vexnum; j++)
			G.arcs[i][j] = INFINITYA;

	for (k = 0; k < G.arcnum; k++)
	{
		cout << k;
		cout << "请输入两个顶点:";
		cin >> v1 >> v2;
		getchar();
		i = LocateVex(G, v1);
		j = LocateVex(G, v2);
		G.arcs[i][j] = 1;
	}
	return OK;
}


int FirstAdjVex(MGraph G, int v)
{
	int i;
	for (i = 0; i < G.vexnum; i++)
	{
		if (G.arcs[v][i] == 1)
			return i;
	}
	return -1;
}

int NextAdjVex(MGraph G, int u, int w)
{
	for (int i = w + 1; i < G.vexnum; i++)
	{
		if (G.arcs[u][i] == 1)
			return i;
	}
	return -1;
}
void BFSTraverse(MGraph G)
{
	SqQueue Q;
	int v, u, w, visited[MAX_VERTAX_NUM];
	for (v = 0; v < G.vexnum; ++v)
		visited[v] = FALSE;
	InitQueue(Q);
	for (v = 0; v < G.vexnum; v++)
	{
		if (!visited[v]) //尚未访问
		{
			visited[v] = TRUE; //访问并标记
			cout << G.vexs[v]; //遍历 输出
			EnQueue(Q, v); //v 入队
			while (!QueueEmpty(Q))
			{
				DeQueue(Q, u); //队头元素出队并置为u
				for (w = FirstAdjVex(G, u); w >= 0; w = NextAdjVex(G, u, w)) //遍历边
				{
					if (!visited[w])
					{
						visited[w] = TRUE;
						cout << G.vexs[w];
						EnQueue(Q, w);
					}
				}
			}
		}
	}
	cout << "广度优先搜索完成" << endl;
}



int main() {
	MGraph G;
	CreateDG(G);
	BFSTraverse(G);   

	return 0;
}

···
十里青柚
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之广度优先搜索 详尽的PPT动态讲解
01-16
数据结构之广度优先搜索 详尽的PPT动态讲解
深度优先搜索 广度优先搜索
开心就好
04-14 5929
深度优先搜索 广度优先搜索 通过邻接矩阵对图进行深搜和广搜 package com.neusoft.data.structure; /** * 深度优先搜索 广度优先搜索 * 通过邻接矩阵对图进行深搜和广搜 */ public class DFSBFS { private ch...
图——存储结构为邻接表表示的图的深度优先搜索递归算法详解
fu_jian_ping的博客
03-31 3159
深度优先搜索的算法思想： 设初始状态时图中的所有顶点都未被访问，则： （1）：从图中某个顶点i出发，访问i; 然后找到i的一个邻接顶点i1; （2）：从i1出发，深度优先搜索访问和i1相邻接且未被访问的所有顶点； （3）：转（1），直到和i相邻接的所有顶点都被访问为止； （4）：继续选取图中未被访问顶点j作为其实顶点，转（1），直到图中所有顶点都...
广度优先搜索
Viator
04-19 140
各种图搜索之间的区别，体现为边分类结果的不同，以及所得遍历树(森林)的结构差异。其决定因素在于，搜索过程中的每一步迭代，将依照何种策略来选取下一接受访问的顶点。 广度优先搜索的策略是，越早访问的顶点，其邻居优先被选用。 BFS，借助队列Q，来保存已被发现，但尚未访问完毕的顶点。因此，任何顶点在进入该队列的同时，都被随即标记为DISCOVERED(已被发现)的状态。 BFS的每一步迭代，都...
【数据结构】-树及森林 菜单实现 深度优先 广度优先 递归遍历
老汉健身的博客
10-25 1737
前言:树是一种非常有趣的数据结构,在大学时期有学过,但缺乏实际运用场景,所以学完后来就忘得差不多了...但工作以后才发现,树这种数据结构是那么重要和常见,用得好的话可以让你代码更优雅,性能更佳,为了让树里面的概念更易于理解,关于树的定义这块我尽量通俗,牺牲一些标准性,提高可读性,不至于像读大学课本上对树的定义那样难懂. 1.基本概念 1.1定义 树:是由结点或顶点和边组成的(可能是非线性的)...
深度广度优先搜索
12-07
在提供的压缩包文件“深度广度优先搜索”中，可能包含了实现这两种搜索算法的源代码，这将是一个很好的学习资源，帮助你理解并实践这些重要算法。通过阅读和运行代码，你将有机会观察算法的运行过程，加深对算法的...
python深度优先搜索和广度优先搜索
09-20
Python中的深度优先搜索（DFS, Depth First Search）和广度优先搜索（BFS, Breadth First Search）是图论和数据结构中常见的两种遍历算法，用于遍历或搜索树或图。这两种算法在解决诸如查找路径、检测环路、找出连通...
C++实现广度优先搜索实例
01-01
图的遍历主要有两种算法：广度优先搜索（Breadth-First-Search）和深度优先搜索（Depth-First-Search）。 一、广度优先搜索（BFS）的算法思想 广度优先搜索类似于二叉树的层序遍历，它的基本思想就是：首先访问起始...
shendu.rar_广度优先_深度优先搜索
09-20
**深度优先搜索(DFS, Depth First Search)与广度优先搜索(BFS, Breadth First Search)**是图论和树形结构中两种基本的遍历算法，广泛应用于计算机科学的各个领域，如图形渲染、游戏AI、网络路由、数据结构的遍历等。...
用深度优先、广度优先算法解决八数码问题
04-18
标题中的“用深度优先、广度优先算法解决八数码问题”指的是在计算机科学领域中，利用两种经典的图遍历算法——深度优先搜索（DFS, Depth-First Search）和广度优先搜索（BFS, Breadth-First Search）来解决八数码...
深度优先查找和广度优先查找
qq_53226437的博客
03-15 724
深度优先查找和广度优先查找 在人工智能和运筹学的领域中求解与图有关的许多应用中，这两个算法被 证明是非常有用的。并且，如需高效地研究图的基本性质，例如图的连通性以及图是否存 在环，这些算法也是必不可少的。 深度优先查找 深度优先查找可以从任意顶点开始访问图的项点，然后把该顶点标记为已访问。在每次迭代的时候，该算法紧接着处理与当前顶点邻接的未访问顶点。（如果有若干个这样的顶点，可以任意选择一个顶点。但在实际应用中，选择哪一个邻接的未访问候选顶点主要是由表示图的数据结构决定的。在我们的例子中，我们总是根据顶点的
图的邻接表创建和深度优先搜索
两书卷的博客
04-12 382
注意：定义的单链表中的节点类型时，int adjvex 指向的是顶点的位置，而不是顶点的值 #include #include using namespace std; typedef struct ArcNode {     int adjvex;                  //该边指向的顶点在顺序表中的位置，是位置不是值的大小。     struct A
图（深度优先搜索&&广度优先搜索）
agate_zhang的博客
07-10 1062
图 1.基础知识        图是一种非线性结构，由顶点集合（vertex）及顶点间的关系集合组成的一种数据结构     Graph=（V,E）；V={x|x是顶点的集合}；E={|x,y属于V}     如下图                  图可以分为有向图和无向图两种。             完全图：在由n个顶点组成的无向图中，若有N(N-1)/2条边，则称为
无向图的深度优先生成森林（第七章 P170 算法7.7,7.8）
但行好事，莫问前程
04-20 1533
具有 n 个顶点的无向连通图至少有 n-1 条边，如果只有 n-1 条边，则不会形成环，这样的图称为“生成树”。连通图可通过遍历构造生成树，非连通图的每个连通分量可构造一棵生成树，整个非连通图构造为生成森林。 下面程序调用算法 7.7、7.8，将无向图构造为生成森林，并以孩子—兄弟二叉链表存储之。 typedef int Status; /* Status是函数的类型,其值是函数结果状...
python 实现图的深度优先和广度优先搜索
weixin_30646505的博客
06-28 2394
在介绍 python 实现图的深度优先和广度优先搜索前，我们先来了解下什么是“图”。1 一些定义顶点顶点（也称为“节点”）是图的基本部分。它可以有一个名称，我们将称为“键”。边边（也称为“弧”）是图的另一个基本部分。边连接两个顶点，以表明它们之间存在关系。权重边可以被加权以示出从一个顶点到另一个顶点的成本。例如，在将一个城市连接到另...
【数据结构与算法python】广度优先搜索算法
思南的博客
09-10 479
1、引入 由 “ 爱 丽 丝 漫 游 奇 境 ” 的 作 者 LewisCarroll在1878年所发明的单词游戏，从一个单词演变到另一个单词， 其中的过程可以经过多个中间单词，要求是相邻两个单词之间差异只能是1个字母， 如FOOL变SAGE： FOOL >> POOL >> POLL >> POLE >> PALE>> SALE >> SAGE 2、功能分析 在上述问题中，我们的目标是找到最短的单词变换序列 采用图来解决这个问题的步骤
图的广度和深度优先路径搜索算法(python实现)
追光少年的博客
07-15 4788
图是一种抽象数据结构，本质和树结构是一样的。图与树相比较，图具有封闭性，可以把树结构看成是图结构的前生。在树结构中，如果把兄弟节点之间或子节点之间横向连接，便构建成一个图。树适合描述从上向下的一对多的数据结构，如公司的组织结构。图适合描述更复杂的多对多数据结构，如复杂的群体社交关系。根据图的特性，图数据结构中至少要包含两类信息所有顶点构成集合信息，这里用V表示（如地图程序中，所有城市构在顶点集合）。所有边构成集合信息，这里用E表示（城市与城市之间的关系描述）。如何描述边？G表示图，则。，...
Python之邻接表(数据结构)
wn2001的博客
06-09 4273
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 案例来源于© Fu Xianjun. All Rights Reserved. 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warnings warnings.filterwarnings('ignore') import ssl ssl.
图的广度优先遍历(邻接表)
热门推荐
t_wu的博客
04-13 2万+
1.广度优先遍历        图的广度优先遍历类似于数的层序遍历，它的思想是从一个顶点V0开始，辐射状地优先遍历其周围较广的区域。以上便是广度优先遍历的一次过程（没循环）for 循环存放顶点的数组        如果当前顶点值未被访问过                访问它并且将它对应的判断数组变为true                将它入队                        w...
C语言深度广度优先搜索
最新发布
11-06
深度优先搜索和广度优先搜索是图论中的两个基本算法，它们在C语言中的实现方式如下： 深度优先搜索（DFS）：深度优先搜索是一种递归的算法，它从图的某个顶点开始遍历，尽可能深地搜索图的分支，直到不能再继续为止...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值