有向图深度和广度优先遍历问题（基本概念，别笑我）

jackyjkchen 2012-10-05 08:01:42
举个最简单的有向图

b -> a -> c

设a是第一个顶点，这样的有向图从a只能走到c，不可能走到b，那么从a进行遍历，b是否应该遍历到？

我开始一直不太明白严蔚敏书上深度广度优先遍历最外层的那个循环是干吗的，现在明白加上外层的循环就可以处理这种从第一顶点无法到达的顶点，但这样就很奇怪，路径是断的，b相当于凭空冒出来

以下是根据严蔚敏书上逻辑写的代码





#include <stdio.h>

#include <stdint.h>

#include <stack>

#include <queue>

using namespace std;



#define MAX_NODE 26



typedef int InfoType;

typedef int ElemType;

typedef int VRType;

typedef char VertexType;



typedef enum

{

	DG = 0,

	DN,

	UDG,

	UDN

}GraphKind;



typedef struct ArcCell

{

	VRType adj;

	InfoType *info;

}ArcCell, AdjMatrix[MAX_NODE][MAX_NODE];



typedef struct

{

	VertexType vexs[MAX_NODE];

	AdjMatrix arcs;

	int vexnum;

	int arcnum;

	GraphKind kind;

}MGraph;



void BuildUDG(MGraph *G)

{

	int i = 0, j = 0, k = 0;

	char c = 'a';

	int n1[] = {0, 0, 1, 1, 2, 2, 3, 4, 5};

	int n2[] = {1, 2, 3 ,4, 5, 6, 7, 7, 6};

	if (!G)

		return;

	G->vexnum = 8;

	G->arcnum = 9;

	G->kind = UDG;

	for (i=0; i<G->vexnum; ++i)

		G->vexs[i] = c++;

	for (i=0; i<G->vexnum; ++i)

	{

		for (j=0; j<G->vexnum; ++j)

		{

			G->arcs[i][j].adj = 0;

			G->arcs[i][j].info = NULL;

		}

	}

	for (k=0; k<G->arcnum; ++k)

	{

		G->arcs[n1[k]][n2[k]].adj = 1;

		G->arcs[n2[k]][n1[k]].adj = G->arcs[n1[k]][n2[k]].adj;

	}

}



static unsigned char visited[MAX_NODE] = {0};



int NextAdjVex(MGraph *G, int v, int w)

{

	int i = 0;

	if (!G || v < 0)

		return -1;

	for (i=++w; i<G->vexnum; ++i)

		if (G->arcs[v][i].adj != 0 && G->arcs[v][i].adj != INT32_MAX)

			return i;

	return -1;

}



void DFS(MGraph *G, int v)

{

	int i = 0;

	if (!G)

		return;

	visited[v] = 1;

	printf("%c ", G->vexs[v]);

	for (i=NextAdjVex(G, v, -1); i>=0; i=NextAdjVex(G, v, i))

	{

		if (!visited[i])

			DFS(G, i);

	}

}



void DFSRecursion(MGraph *G)

{

	int i = 0;

	if (!G)

		return;

	for (i=0; i<G->vexnum; ++i)

		visited[i] = 0;

	for (i=0; i<G->vexnum; ++i)

	{

		if (!visited[i])

			DFS(G, i);

	}

	printf("\n");

}



void DFSStack(MGraph *G)

{

	int i = 0, j = 0, k = 0;

	stack<int> s;

	if (!G)

		return;

	for (i=0; i<G->vexnum; ++i)

		visited[i] = 0;

	for (i=0; i<G->vexnum; ++i)

	{

		if (!visited[i])

		{

			visited[i] = 1;

			printf("%c ", G->vexs[i]);

			s.push(i);

			while (!s.empty())

			{

				j = s.top();

				s.pop();

				for (k=NextAdjVex(G, j, -1); k>=0; k=NextAdjVex(G, j, k))

				{

					if (!visited[k])

					{

						visited[k] = 1;

						printf("%c ", G->vexs[k]);

						s.push(k);

						j = k;

					}

				}

			}

		}

	}

	printf("\n");

}



void BFSQueue(MGraph *G)

{

	int i = 0, j = 0, k = 0;

	queue<int> s;

	if (!G)

		return;

	for (i=0; i<G->vexnum; ++i)

		visited[i] = 0;

	for (i=0; i<G->vexnum; ++i)

	{

		if (!visited[i])

		{

			visited[i] = 1;

			printf("%c ", G->vexs[i]);

			s.push(i);

			while (!s.empty())

			{

				j = s.front();

				s.pop();

				for (k=NextAdjVex(G, j, -1); k>=0; k=NextAdjVex(G, j, k))

				{

					if (!visited[k])

					{

						visited[k] = 1;

						printf("%c ", G->vexs[k]);

						s.push(k);

					}

				}

			}

		}

	}

	printf("\n");

}



int main()

{

	MGraph G = {0};

	BuildUDG(&G);

	DFSRecursion(&G);

	DFSStack(&G);

	BFSQueue(&G);

	getchar();

}
...全文
2767 19 打赏 收藏 转发到动态 举报
写回复
用AI写文章
19 条回复
切换为时间正序
请发表友善的回复…
发表回复
bys1991 2012-12-01
  • 打赏
  • 举报
 回复
引用 9 楼 jackyjkchen 的回复:
引用 7 楼 的回复:G->arcs[n1[k]][n2[k]].adj = 1; G->arcs[n2[k]][n1[k]].adj = G->arcs[n1[k]][n2[k]].adj;这个不是无向图吗？ 我代码是无向图，就是因为无向图代码发现外层循环是没用的，才想到有向图的问题
无向图外层循环也是有用的，你没发现有用是因为你输入的无向图都是连通图。而你给出的有向图是一个非强连通图，所以外层循环就有意义了。
Finalcheat 2012-10-05
  • 打赏
  • 举报
 回复
去看《算法导论》吧，里面说的很清楚。
jackyjkchen 2012-10-05
  • 打赏
  • 举报
 回复
不对啊，是先打印再遍历，独立节点是能打出来的，我给你说糊涂了



void DFS(MGraph *G, int v)

{

    int i = 0;

    if (!G)

        return;

    visited[v] = 1;

    printf("%c ", G->vexs[v]);

    for (i=NextAdjVex(G, v, -1); i>=0; i=NextAdjVex(G, v, i))

    {

        if (!visited[i])

            DFS(G, i);

    }

}

newtee 2012-10-05
  • 打赏
  • 举报
 回复
我指的是无向图的情况下 对于有向图这方法挺不错的 说反了
newtee 2012-10-05
  • 打赏
  • 举报
 回复
[Quote=引用 13 楼 的回复:]

引用 11 楼 的回复:
for (i=0; i<G->vexnum; ++i)
{
if (!visited[i])
DFS(G, i);
}感觉只是为了从0开始遍历 后面顶点的值就为1了 if里的条件也不满足了 不懂为什么这么写


不说了么，后面的顶点如果无法从第一顶点遍历到，这个循环就有用了
[/Quote]我指的是有向图的情况下 对于无向图这方法挺不错的
jackyjkchen 2012-10-05
  • 打赏
  • 举报
 回复
[Quote=引用 12 楼 的回复:]
感觉只是为了从0开始遍历 后面顶点的visit值就为1了 if里的条件也不满足了 不懂为什么这么写


对于你说的情况是遍历不到的 见于10楼红字体
[/Quote]
你说得对，这是个问题
jackyjkchen 2012-10-05
  • 打赏
  • 举报
 回复
[Quote=引用 11 楼 的回复:]
for (i=0; i<G->vexnum; ++i)
{
if (!visited[i])
DFS(G, i);
}感觉只是为了从0开始遍历 后面顶点的值就为1了 if里的条件也不满足了 不懂为什么这么写
[/Quote]

不说了么，后面的顶点如果无法从第一顶点遍历到，这个循环就有用了
newtee 2012-10-05
  • 打赏
  • 举报
 回复
感觉只是为了从0开始遍历 后面顶点的visit值就为1了 if里的条件也不满足了 不懂为什么这么写


对于你说的情况是遍历不到的 见于10楼红字体



newtee 2012-10-05
  • 打赏
  • 举报
 回复
for (i=0; i<G->vexnum; ++i)
{
if (!visited[i])
DFS(G, i);
}感觉只是为了从0开始遍历 后面顶点的值就为1了 if里的条件也不满足了 不懂为什么这么写
newtee 2012-10-05
  • 打赏
  • 举报
 回复
int NextAdjVex(MGraph *G, int v, int w)
{
int i = 0;
if (!G || v < 0)
return -1;
for (i=++w; i<G->vexnum; ++i)
if (G->arcs[v][i].adj != 0 && G->arcs[v][i].adj != INT32_MAX)
return i;
return -1;
}
jackyjkchen 2012-10-05
  • 打赏
  • 举报
 回复
[Quote=引用 7 楼 的回复:]

G->arcs[n1[k]][n2[k]].adj = 1;
G->arcs[n2[k]][n1[k]].adj = G->arcs[n1[k]][n2[k]].adj;这个不是无向图吗？
[/Quote]

我代码是无向图，就是因为无向图代码发现外层循环是没用的，才想到有向图的问题
Finalcheat 2012-10-05
  • 打赏
  • 举报
 回复
BFS和DFS是对图的节点搜索顺序的算法，并不是找某一节点的所有路径。
newtee 2012-10-05
  • 打赏
  • 举报
 回复
G->arcs[n1[k]][n2[k]].adj = 1;
G->arcs[n2[k]][n1[k]].adj = G->arcs[n1[k]][n2[k]].adj;这个不是无向图吗？
a784063999 2012-10-05
  • 打赏
  • 举报
 回复
完全不明白
Finalcheat 2012-10-05
  • 打赏
  • 举报
 回复
[Quote=引用 4 楼 的回复:]

C/C++ code

void DFSRecursion(MGraph *G)
{
int i = 0;
if (!G)
return;
for (i=0; i<G->vexnum; ++i)
visited[i] = 0;
for (i=0; i<G->vexnum; ++i) //如果不需要遍历那些不可能走到的节点，那这个循……
[/Quote]
哦，你是这个意思啊，DFS当然会对没有遍历的节点进行遍历，但不代表是从a走到b，当a的所有路径都走完的时候就会遍历b。
jackyjkchen 2012-10-05
  • 打赏
  • 举报
 回复 


void DFSRecursion(MGraph *G)

{

    int i = 0;

    if (!G)

        return;

    for (i=0; i<G->vexnum; ++i)

        visited[i] = 0;

    for (i=0; i<G->vexnum; ++i) //如果不需要遍历那些不可能走到的节点，那这个循环根本不需要

    {

        if (!visited[i])

            DFS(G, i);

    }

    printf("\n");

}
Finalcheat 2012-10-05
  • 打赏
  • 举报
 回复
[Quote=引用 2 楼 的回复:]
问题就是严蔚敏书上的代码就是让你能遍历到b！否则没必要加最外层循环
[/Quote]
我没看过严蔚敏书上的代码，但是按你所说的那个有向图是从a出发绝对不可能到达b的。
jackyjkchen 2012-10-05
  • 打赏
  • 举报
 回复
[Quote=引用 1 楼 的回复:]
从a出发当然不可能走到b，也不可能遍历到b，这不是很明显的么？
[/Quote]

问题就是严蔚敏书上的代码就是让你能遍历到b！否则没必要加最外层循环
Finalcheat 2012-10-05
  • 打赏
  • 举报
 回复
从a出发当然不可能走到b，也不可能遍历到b，这不是很明显的么？
“动画讲解+手写代码”走进数据结构+算法
一、通过图解原理+手写代码实现，深度讲解如下基本数据结构: 基本二叉树、23树、红黑树、B树、B+树、B*树等等 同时还介绍了硬盘运行原理（主要描述与树结构的关系）、数据库索引原理（主要描述与树结构关系）等用到树结构的软硬件。 二、通过图解9道经典题目，讲解如下基本算法: 深度优先穷竭算法（深度枚举遍历）、广度优先穷竭算法（广度枚举遍历）、各种场景的贪心算法等等
算法：深度优先遍历和广度优先遍历
什么是深度、广度优先遍历 深度优先遍历简称DFS（Depth First Search），广度优先遍历简称BFS（Breadth First Search），它们是遍历图当中所有顶点的两种方式。 这两种遍历方式有什么不同呢？ 举个例子。我们来到一个游乐场，游乐场里有11个景点。我们从景点0开始，要玩遍游乐场的所有景点，可以有什么样的游玩次序呢？ 第一种是一头扎到底的玩法。我们选择一条支路，尽可能不断地深入，如果遇到死路就往回退，回退过程中如果遇到没探索过的支路，就进入该支路继续深入。 在图中，我们首先选择
深度优先遍历和广度优先遍历
深度优先遍历和广度优先遍历 深度优先遍历和广度优先遍历是遍历图当中所有顶点的两种方式。 深度优先遍历（DFS） 顾名思义，深度优先遍历就是找准一条路不停深入的搜索方法，当发现这条路走不通的时候就会回退到上一个探索的节点，如果上一个节点存在没有探索的分支，便继续探索若没有则继续回退。深度优先遍历就有点像二叉树中的前序、中序和后序遍历。 深度优先遍历的关键就在于如何找到已经探索过节点的上一个节点，也就是如何回溯。 深度优先算法示意图 线上标注的便是探索的顺序，可以看出深度优先遍历是走到头再回退寻找其他出路的遍
图的深度优先遍历(DFS)和广度优先遍历(BFS)算法分析
遍历深度优先遍历无向图的深度优先遍历图解有向图的深度优先遍历图解广度优先遍历无向图的广度优先遍历图解有向图的广度优先遍历图解 图的遍历，所谓遍历，即是对结点的访问。一个图有那么多个结点，如何遍历这些结点，需要特定策略，一般有两种访问策略： 深度优先遍历 广度优先遍历 深度优先遍历 深度优先遍历(Depth First Search)的主要思想是： 首先以一个未被访问过的顶点作为起始顶点，沿当前顶点的边走到未访问过的顶点； 当没有未访问过的顶点时，则回到上一个顶点，继续试探别的顶点，直至所有的
图的深度优先遍历和广度优先遍历
一、写在前面 图的深度优先遍历和广度优先遍历，也是我们必须要明白的算法。下面我们以有向图为了，来总结一下，图是如何做到深度优先遍历和广度优先遍历的。 使用数组表示如下所示 let graph = { 0: [1, 2], 1: [2], 2: [0, 3], 3: [3] } 二、深度优先遍历 const graph = require('./database') let set = new Set() //使用Set数据结构来保存已经访问了的node节点。 const dfs =
其它技术问题

3,881

社区成员

9,054

社区内容

发帖
与我相关
我的任务
社区描述
C/C++ 其它技术问题
社区管理员
  • 其它技术问题社区
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章