矩阵版本图的深度优先和广度优先遍历

最新推荐文章于 2022-05-07 09:13:55 发布
最新推荐文章于 2022-05-07 09:13:55 发布
阅读量664 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzjsqn/article/details/26096507
版权

链式队列头文件

#ifndef _LINKQUEUE_H_
#define _LINKQUEUE_H_

typedef void LinkQueue;

LinkQueue* LinkQueue_Create();

void LinkQueue_Destroy(LinkQueue* queue);

void LinkQueue_Clear(LinkQueue* queue);

int LinkQueue_Append(LinkQueue* queue, void* item);

void* LinkQueue_Retrieve(LinkQueue* queue);

void* LinkQueue_Header(LinkQueue* queue);

int LinkQueue_Length(LinkQueue* queue);

#endif


链式队列实现文件

#include <malloc.h>
#include <stdio.h>
#include "LinkQueue.h"

typedef struct _tag_LinkQueueNode TLinkQueueNode;
struct _tag_LinkQueueNode{
	TLinkQueueNode* next;
	void* item;
};

typedef struct _tag_LinkQueue{
	TLinkQueueNode* front;
	TLinkQueueNode* rear;
	int length;
}TLinkQueue;

LinkQueue* LinkQueue_Create()
{
	TLinkQueue* ret = (TLinkQueue*)malloc(sizeof(TLinkQueue));

	if (ret != NULL){
		ret->front = NULL;
		ret->rear = NULL;
		ret->length = 0;
	}
	return ret;
}

void LinkQueue_Destroy(LinkQueue* queue)
{
	LinkQueue_Clear(queue);
	free(queue);
}

void LinkQueue_Clear(LinkQueue* queue)
{
	while (LinkQueue_Length(queue) > 0){
		LinkQueue_Retrieve(queue);
	}
}

int LinkQueue_Append(LinkQueue* queue, void* item)
{
	TLinkQueue* sQueue = (TLinkQueue*)queue;
	TLinkQueueNode* node = (TLinkQueueNode*)malloc(sizeof(TLinkQueueNode));

	int ret = (sQueue != NULL) && (item != NULL) && (node != NULL);

	if (ret){
		node->item = item;
		if (sQueue->length > 0){
			sQueue->rear->next = node;
			sQueue->rear = node;
			node->next = NULL;
		}
		else{
			sQueue->front = node;
			sQueue->rear = node;
			node->next = NULL;
		}
		sQueue->length++;
	}
	if (!ret){
		free(node);
	}
	return ret;
}

void* LinkQueue_Retrieve(LinkQueue* queue)
{
	TLinkQueue* sQueue = (TLinkQueue*)queue;
	void* ret = NULL;
	TLinkQueueNode* node = NULL;
	if ((sQueue != NULL) && (sQueue->length > 0)){
		node = sQueue->front;

		sQueue->front = node->next;

		ret = node->item;

		free(node);

		sQueue->length--;


		if (0 == sQueue->length){
			sQueue->front = NULL;
			sQueue->rear = NULL;
		}
	}
	return ret;
}

void* LinkQueue_Header(LinkQueue* queue)
{
	TLinkQueue* sQueue = (TLinkQueue*)queue;
	void* ret = NULL;
	if ((sQueue != NULL) && (sQueue->length > 0)){
		ret = sQueue->front->item;
	}
	return ret;
}

int LinkQueue_Length(LinkQueue* queue)
{
	TLinkQueue* sQueue = (TLinkQueue*)queue;
	int ret = -1;
	if (sQueue != NULL){
		ret = sQueue->length;
	}
	return ret;
}


图的头文件

/***************************************************************
*版权所有 (C)2014,练习。
*
*文件名称：
*内容摘要：
*其它说明：
*当前版本：
*作   者：
*完成日期：
*
*修改记录1：  //修改历史记录，包括修改日期、版本号、修改人及修改内容等
*   修改日期：
*   版本号：
*   修改人：
*   修改内容：
***************************************************************/
#ifndef __MGRAPH_H__
#define __MGRAPH_H__

/**************************************************************
相关宏定义
**************************************************************/

/**************************************************************
相关结构体定义
**************************************************************/


typedef void MGraph;//图的结构体定义，数据封装形式

typedef void MVertex;//顶点的结构体定义，数据封装形式

typedef void (MGraph_printf)(MVertex*);//重命名一个函数类型用来打印信息


/**************************************************************
创建一个顶点数为n的图，并返回其地址
**************************************************************/
MGraph* MGraph_Create(MVertex** v, int n);


/**************************************************************
销毁graph指向的图
**************************************************************/
void MGraph_Destroy(MGraph* graph);


/**************************************************************
将graph指向的图清空（清空的是顶点之间的边，而不是顶点本身）
**************************************************************/
void MGraph_Clear(MGraph* graph);


/**************************************************************
在graph所指的图中v1和v2之间加上边，且边的权为w
**************************************************************/
int MGraph_AddEdge(MGraph* graph, int v1, int v2, int w);


/**************************************************************
将graph所指图中v1和v2之间的边删除，返回权值
**************************************************************/
int MGraph_RemoveEdge(MGraph* graph, int v1, int v2);



/**************************************************************
将graph所指图中v1和v2之间的边的权值返回
**************************************************************/
int MGraph_GetEdge(MGraph* graph, int v1, int v2);


/**************************************************************
将graph所指图中v顶点的度返回
**************************************************************/
int MGraph_TD(MGraph* graph, int v);


/**************************************************************
将graph所指图中的顶点数返回
**************************************************************/
int MGraph_VertexCount(MGraph* graph);


/**************************************************************
将graph所指图中的边数返回
**************************************************************/
int MGraph_EdgeCount(MGraph* graph);


/**************************************************************

**************************************************************/
void MGraph_DFS(MGraph* graph, int v, MGraph_printf* pFunc);

/**************************************************************

**************************************************************/
void MGraph_BFS(MGraph* graph, int v, MGraph_printf* pFunc);

/**************************************************************
将graph所指图中的顶点之间的关系打印出来
**************************************************************/
void MGraph_Display(MGraph* graph, MGraph_printf* pFunc);

#endif


图的实现文件

/***************************************************************
*版权所有 (C)2014,公司名称。
*
*文件名称：
*内容摘要：
*其它说明：
*当前版本：
*作   者：
*完成日期：
*
*修改记录1：   //修改历史记录，包括修改日期、版本号、修改人及修改内容等
*   修改日期：
*   版本号：
*   修改人：
*   修改内容：
*
*修改记录2：  //修改历史记录，包括修改日期、版本号、修改人及修改内容等
*   修改日期：
*   版本号：
*   修改人：
*   修改内容：
***************************************************************/



/**************************************************************
头文件引用
**************************************************************/
#include <stdio.h>
#include <malloc.h>
#include "MGraph.h"
#include "LinkQueue.h"

/**************************************************************
全局变量定义
**************************************************************/

typedef struct _tag_MGraph{
	int count;//顶点数量
	MVertex** v;//描述顶点相关数据的指针
	int** matrix;//（邻阶矩阵）描述顶点之间的边的关系的指针
}TMGraph;



static void recursive_dfs(TMGraph* graph, int v, int visited[], MGraph_printf* pFunc)
{
	int i = 0;
	pFunc(graph->v[v]);

	visited[v] = 1;//1表示已经访问过
	printf(",");

	for (i = 0; i < graph->count; i++){//(改为矩阵版本的图以后只需要访问二维矩阵的某一行)
		
		if ((!visited[i]) && (graph->matrix[v][i] != 0)){
			recursive_dfs(graph, i, visited, pFunc);
		}
	}
}

/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：需要用到队列
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYLLDD            XXX             Name            YYY
***********************************************************************/
static void recursive_bfs(TMGraph* graph, int v, int visited[], MGraph_printf* pFunc)
{
	LinkQueue* queue = LinkQueue_Create();

	if (queue != NULL)
	{
		LinkQueue_Append(queue, graph->v + v);//插入的是地址，因为队列里面不能插入0，所以插入地址，后面访问的时候求											//相对地址来代表实际的数据，graph->v是基地址

		visited[v] = 1;//表示已经访问过

		while (LinkQueue_Length(queue) > 0)//递归结束的条件，全部遍历过
		{
			int i = 0;

			v = (MVertex**)LinkQueue_Retrieve(queue) - graph->v;//将队列里面的数据取出，即访问刚刚插入的节点

			pFunc(graph->v[v]);

			printf(",");

			for (i = 0; i < graph->count; i++)//依次访问下一层(改为矩阵版本的图以后只需要访问二维矩阵的某一行)
			{

				if ((!visited[i]) && (graph->matrix[v][i] != 0))//如果没有访问过则加入队列以便访问
				{
					LinkQueue_Append(queue, graph->v +i);//插入地址

					visited[i] = 1;//标记已经访问
				}
			}
		}
	}

	LinkQueue_Destroy(queue);//有创建必然伴随着销毁
}
/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYMMDD            XXX             Name            YYY
***********************************************************************/
MGraph* MGraph_Create(MVertex** v, int n)
{
	TMGraph* ret = NULL;
	if ((v != NULL) && (n > 0)){//有穷非空所以n大于0
		ret = (TMGraph*)malloc(sizeof(TMGraph));//申请一个头节点对象
		if (ret != NULL){
			int* p = NULL;
			ret->count = n;

			ret->v = (MVertex**)malloc(sizeof(MVertex*)* n);//申请顶点书据相关的指针空间


			ret->matrix = (int**)malloc(sizeof(int*)* n);//动态申请二维数组
			p = (int*)calloc(n * n, sizeof(int));//为了避免二重循环，使用calloc使其自动初始化数据空间


			if ((ret->v != NULL) && (ret->matrix != NULL) && (p != NULL)){
				int i = 0;
				for (i = 0; i < n; i++){
					ret->v[i] = v[i];//保存顶点的数据指针
					ret->matrix[i] = p + n*i;//建立一维指针数组到数据空间的链接
				}
			}
			else{//申请不成功要释放空间
				free(p);
				free(ret->v);
				free(ret->matrix);
				free(ret);
				ret = NULL;
			}
		}
	}
	return ret;
}

/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYMMDD            XXX             Name            YYY
***********************************************************************/
void MGraph_Destroy(MGraph* graph)
{
	TMGraph* tGraph = (TMGraph*)graph;
	if (tGraph != NULL){
		free(tGraph->v);//释放顶点相关的数据空间


		free(tGraph->matrix[0]);//必须先释放数据空间
		free(tGraph->matrix);//再释放一维指针数组空间


		free(tGraph);//最后释放头节点（图本身）
	}
}



/**********************************************************************
*功能描述：清空的是边，而不是顶点
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYMMDD            XXX             Name            YYY
***********************************************************************/
void MGraph_Clear(MGraph* graph)
{
	TMGraph* tGraph = (TMGraph*)graph;
	if (tGraph != NULL){
		int i = 0, j = 0;
		for (i = 0; i < tGraph->count; i++){
			for (j = 0; j < tGraph->count; j++){
				tGraph->matrix[i][j] = 0;
			}
		}
	}
}

/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYMMDD            XXX             Name            YYY
***********************************************************************/
int MGraph_AddEdge(MGraph* graph, int v1, int v2, int w)
{
	TMGraph* tGraph = (TMGraph*)graph;

	int ret = (tGraph != NULL);
	ret = ret && (v1 >= 0) && (v1 < tGraph->count);
	ret = ret && (v2 >= 0) && (v2 < tGraph->count);
	ret = ret && (w >= 0);

	if (ret){
		tGraph->matrix[v1][v2] = w;
	}
	return 0;
}



/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYMMDD            XXX             Name            YYY
***********************************************************************/
int MGraph_RemoveEdge(MGraph* graph, int v1, int v2)
{
	TMGraph* tGraph = (TMGraph*)graph;
	int ret = MGraph_GetEdge(graph, v1, v2);//代码复用

	if (ret != 0){
		tGraph->matrix[v1][v2] = 0;
	}
	return ret;
}

/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYMMDD            XXX             Name            YYY
***********************************************************************/
int MGraph_GetEdge(MGraph* graph, int v1, int v2)
{
	TMGraph* tGraph = (TMGraph*)graph;
	int condition = (tGraph != NULL);
	int ret = 0;
	condition = condition && (v1 >= 0) && (v1 < tGraph->count);
	condition = condition && (v2 >= 0) && (v2 < tGraph->count);
	if (condition){
		ret = tGraph->matrix[v1][v2];
	}
	return ret;
}

/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYMMDD            XXX             Name            YYY
***********************************************************************/
int MGraph_TD(MGraph* graph, int v)
{
	TMGraph* tGraph = (TMGraph*)graph;
	int condition = (tGraph != NULL);
	int ret = 0;
	condition = condition && (v >= 0) && (v < tGraph->count);

	if (condition){
		int i = 0;
		for (i = 0; i < tGraph->count; i++){
			if (tGraph->matrix[v][i] != 0){
				ret++;
			}
			if (tGraph->matrix[i][v] != 0){
				ret++;
			}
		}
	}
	return ret;
}


/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYMMDD            XXX             Name            YYY
***********************************************************************/
int MGraph_VertexCount(MGraph* graph)
{
	TMGraph* tGraph = (TMGraph*)graph;

	int ret = 0;
	if (tGraph != NULL){
		ret = tGraph->count;
	}

	return ret;
}

/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYMMDD            XXX             Name            YYY
***********************************************************************/
int MGraph_EdgeCount(MGraph* graph)
{
	TMGraph* tGraph = (TMGraph*)graph;
	int ret = 0;
	if (tGraph != NULL){
		int i = 0, j = 0;
		for (i = 0; i < tGraph->count; i++){
			for (j = 0; j < tGraph->count; j++){
				if (tGraph->matrix[i][j] != 0){
					ret++;
				}
			}
		}
	}
	return ret;
}


/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYLLDD            XXX             Name            YYY
***********************************************************************/
void MGraph_DFS(MGraph* graph, int v, MGraph_printf* pFunc)
{
	TMGraph* tGraph = (TMGraph*)graph;
	int condition = (tGraph != NULL);
	int* visited = NULL;
	condition = condition && (v >= 0) && (v < tGraph->count);
	condition = condition && (pFunc != NULL);
	condition = condition && ((visited = (int*)calloc(tGraph->count, sizeof(int))) != NULL);

	if (condition){
		int i = 0;
		recursive_dfs(tGraph, v, visited, pFunc);//表示当V还有相邻的节点未访问时继续深度遍历相邻节点

		for (i = 0; i < tGraph->count; i++){//表示当v的所有相邻节点已经被访问过，但是图中还有其他节点虽然不与V相邻，										//但还未访问过
			if (!visited[i]){
				recursive_dfs(tGraph, i, visited, pFunc);
			}
		}
	}

	free(visited);

}


/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYLLDD            XXX             Name            YYY
***********************************************************************/
void MGraph_BFS(MGraph* graph, int v, MGraph_printf* pFunc)
{
	TMGraph* tGraph = (TMGraph*)graph;
	int condition = (tGraph != NULL);
	int* visited = NULL;
	condition = condition && (v >= 0) && (v < tGraph->count);
	condition = condition && (pFunc != NULL);
	condition = condition && ((visited = (int*)calloc(tGraph->count, sizeof(int))) != NULL);

	if (condition){
		int i = 0;
		recursive_bfs(tGraph, v, visited, pFunc);//表示当V还有相邻的节点未访问时继续深度遍历相邻节点

		for (i = 0; i < tGraph->count; i++){//表示当v的所有相邻节点已经被访问过，但是图中还有其他节点虽然不与V相邻，										//但还未访问过
			if (!visited[i]){
				recursive_bfs(tGraph, i, visited, pFunc);
			}
		}
	}

	free(visited);
}

/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYMMDD            XXX             Name            YYY
***********************************************************************/
void MGraph_Display(MGraph* graph, MGraph_printf* pFunc)
{
	TMGraph* tGraph = (TMGraph*)graph;
	if ((tGraph != NULL) && (pFunc != NULL)){
		int i = 0;
		int j = 0;


		for (i = 0; i < tGraph->count; i++){
			printf("%d:", i);
			pFunc(tGraph->v[i]);
			printf(" ");
		}
		printf("\n");
		for (i = 0; i < tGraph->count; i++){
			for (j = 0; j < tGraph->count; j++){
				if (tGraph->matrix[i][j] != 0){
					printf("<");
					pFunc(tGraph->v[i]);
					printf(",");
					pFunc(tGraph->v[j]);
					printf(",%d", tGraph->matrix[i][j]);
					printf(">");
					printf(" ");
				}
			}
		}
		printf("\n");
	}
}


测试文件

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

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

void print_data(MVertex* v)
{
	printf("%s", (char*)v);
}

int main(int argc, char *argv[])
{
	MVertex* v[] = { "A", "B", "C", "D", "E", "F" };
	MGraph* graph = MGraph_Create(v, 6);

	MGraph_AddEdge(graph, 0, 1, 1);
	MGraph_AddEdge(graph, 0, 2, 1);
	MGraph_AddEdge(graph, 0, 3, 1);
	MGraph_AddEdge(graph, 1, 5, 1);
	MGraph_AddEdge(graph, 1, 4, 1);
	MGraph_AddEdge(graph, 2, 1, 1);
	MGraph_AddEdge(graph, 3, 4, 1);
	MGraph_AddEdge(graph, 4, 2, 1);

	MGraph_Display(graph, print_data);

	MGraph_DFS(graph, 0, print_data);
	printf("\n");
	MGraph_BFS(graph, 0, print_data);
	printf("\n");
	MGraph_Destroy(graph);
	system("PAUSE");
	return 0;
}



小帅比simon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
图的邻接矩阵表示，深度优先遍历，广度优先遍历实现
03-13
C++实现，数据结构，图的邻接矩阵表示，深度优先遍历，广度优先遍历，DFS，BFS，为什么要五十个字才能上传啊
二维矩阵的深度优先搜索
weixin_40137369的博客
11-01 248
Leetcode 例题： 岛屿数量 https://leetcode-cn.com/problems/number-of-islands/ 单词搜索 https://leetcode-cn.com/problems/word-search/
矩阵中的路径 深度优先
独碟的博客
08-26 238
剑指 Offer 12. 矩阵中的路径 请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。 [["a","b","c","e"], ["s","f","c","s"], ["a","d","e","e"]] 但矩阵中不包含字符串“abfb”的路径，因为字
图的广度优先遍历
考研渣渣斌斌的博客
07-26 220
例题 A同学和B同学一起坐飞机去旅游，他们现在位于1号城市，目标是5号城市 ，可是没有从1号直达5号的航班，不过A同学已经收集了很多的航班信息，现在A同学希望找到一种乘坐方式，使得转机的次数最少，应该如何解决？ 5 7 1 5 1 2 1 3 2 3 2 4 3 4 3 5 4 5 第一行的5表示有5个城市（城市编号为1~5），7表示有7条航线，1表示起点城市，5表示目标城市。接下来7行每行是一条类似“ab”这样的数据表示城市a和城市b之间有航线，也就是说城市a和城市b之间可以相互到达。 这里我们还是使用
图——广度优先遍历和深度优先遍历——邻接矩阵表示法
weixin_30511039的博客
12-13 70
// test20.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include<iostream> #include<vector> #include<string> #include<queue> #include<stack> #include<cstring> #includ...
邻接矩阵存储图的深度优先遍历 邻接矩阵表示图-深度-广度优先遍历
07-05
**深度优先遍历（DFS，Depth First Search）**是从一个顶点开始，尽可能深地探索图的分支，直到到达叶子节点或者回溯到没有未访问过的邻接点为止。在遍历过程中，可以通过访问标志数组`visited`来跟踪哪些顶点已经被...
C++实现图的邻接矩阵存储和广度、深度优先遍历实例分析
09-03
本实例重点讨论了邻接矩阵的实现，并展示了如何进行广度优先遍历(BFS)和深度优先遍历(DFS)。邻接矩阵是一种二维数组，其中的每个元素表示图中两个节点之间是否存在边。如果节点i与节点j之间存在边，则邻接矩阵的[i]...
Graph1_非递归算法进行深度优先遍历和广度优先遍历_
10-02
本话题主要探讨如何使用非递归算法对无向图进行深度优先遍历（DFS, Depth First Search）和广度优先遍历（BFS, Breadth First Search），这两种遍历方法在图算法中有着广泛的应用。 **1. 邻接表表示法** 在处理大...
数据结构之图的表示、深度优先和广度优先遍历.zip
06-21
在这个"数据结构之图的表示、深度优先和广度优先遍历.zip"压缩包中，我们重点探讨的是图这一重要的数据结构，以及如何通过邻接矩阵和邻接表来表示它，以及如何进行深度优先遍历（DFS）和广度优先遍历（BFS）。...
矩阵中的路径(深度优先遍历)
weixin_61898526的博客
05-07 699
。。。。
DFS深度优先遍历（矩阵型）（感染函数）+DFS暴搜
WC949464367的博客
10-16 1371
之前做到的深度优先遍历都是二叉树形式的 ，现在做到矩阵类型的深度优先遍历。话不多说，上代码。 所谓矩阵，便是由二维数组进行构造，DFS探求格子周围的格子，做出相应的判断。 class Solution { public int numIslands(char[][] grid) { int count=0; for(int i=0;i<grid.length;i++){ for(int j=0;j<grid[0].leng.
LeetCode题目分析矩阵——广度优先遍历BFS
exocblly的博客
08-30 286
BFS 广度优先遍历 今天第一次在LeetCode 上练习，题意如下： 给定一个由 0 和 1 组成的矩阵，找出每个元素到最近的 0 的距离。两个相邻元素间的距离为 1 。 示例 1: 输入: 0 0 0 0 1 0 1 1 1 输出: 0 0 0 0 1 0 1 2 1 注意: 给定矩阵的元素个数不超过 10000。 给定矩阵中至少有一个元素是 0。 矩阵中的元素只在四个方向上相邻: 上、下、...
图－广度优先遍历
......
05-20 115
这里的图的广度优先遍历算法利用了队来实现。 图的深度遍历原则： 1 如果有可能，访问所有领接的未访问的节点，标记它们，并把它们放入队中。 2 当不能执行规则 1 时，如果对不为空，则从队中弹出头元素。重新执行规则 1 3 如果不能执行规则 1 和规则 2 时，则完成了遍历。 代码中的图使用的是Graph 图－邻接矩阵法 来表示，其他的表示法请见：Graph 图－邻接表法 代码中的Queue为辅助...
算法：深度优先遍历和广度优先遍历
OceanStar的博客
01-13 8万+
什么是深度、广度优先遍历 深度优先遍历简称DFS（Depth First Search），广度优先遍历简称BFS（Breadth First Search），它们是遍历图当中所有顶点的两种方式。 这两种遍历方式有什么不同呢？ 举个例子。我们来到一个游乐场，游乐场里有11个景点。我们从景点0开始，要玩遍游乐场的所有景点，可以有什么样的游玩次序呢？ 第一种是一头扎到底的玩法。我们选择一条支路，尽可能不断地深入，如果遇到死路就往回退，回退过程中如果遇到没探索过的支路，就进入该支路继续深入。 在图中，我们首先选择
图：图的邻接矩阵创建、深度优先遍历和广度优先遍历详解
重庆李四
02-20 9806
邻接矩阵介绍直接说，邻接矩阵是图的一种存储结构。那么图是什么呢？图是一种逻辑结构，和线性结构、树形结构、集合结构一样 是一种逻辑结构用来描述数据对象中的数据元素之间的关系。来看下图的定义：图（Graph）是有顶点的有穷非空集和顶点之间边的集合组成，通常表示为G（V，E）其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。考虑到图是有顶点和边或弧2部分组成。合在一起比较困难，那就自然的考虑...
深度优先遍历(DFS)和广度优先遍历(BFS)
热门推荐
yimixgg的博客
05-09 19万+
转载：https://blog.csdn.net/rr123rrr/article/details/77971771 图的搜索有两种方式，一种是深度优先搜索（Depth-First-Search），另一种是广度优先搜索（Breadth-First-Search），接下来，我们来写一下这些搜索方式的Java实现，同样的，这里的代码均继承了自定义的EnhanceModual类，我之前的文章（查看En...
数据结构——邻接矩阵的深度优先遍历(DFS)和广度优先遍历(BFS)的理解和实现
weixin_46096297的博客
01-31 3969
数据结构——图的邻接矩阵的遍历
邻接矩阵：深度优先遍历和广度优先遍历
小龙虾
04-30 2327
和邻接表一样，依葫芦画瓢。#include &lt;bits/stdc++.h&gt; using namespace std; #define MAXSIZE 100 int v[MAXSIZE]; int m[MAXSIZE][MAXSIZE]; int n,e; void Init() { int a,b; for(int i=1;i&lt;=MAXSIZE;i++) ...
数据结构---图的邻接矩阵（创建，打印，深度优先遍历，广度优先遍历，C语言）
小陆同学LLR的博客
09-06 4万+
  邻接矩阵法   用一维数组图中顶点的信息，用一个二维数组存储图中边的信息（各顶点之间的邻接关系）。存储顶点之间邻接关系的二维数组称为邻接矩阵。      结点数为n的图G=(V,E)的邻接矩阵A是n*n的，将G的顶点编号为v1,v2,......vn。若（vi,vj)∈E，则A[i][j]=1，否则A[i][j]=0。   对于带权图而言，若顶点vi,vj之间有边相连，则邻接矩阵...
邻接矩阵深度优先遍历和广度优先遍历
最新发布
12-16
邻接矩阵是一种图的存储结构，它可以用来表示有限个顶点之间的关系。邻接矩阵的深度优先遍历和广度优先遍历是图的两种基本遍历方式。 邻接矩阵的深度优先遍历（Depth First Search，DFS）： 深度优先遍历是一种用于遍历或搜索树或图的算法。在这个算法中，首先访问根节点，然后递归地访问每个子节点。当访问一个节点时，将其标记为已访问，以避免重复访问。深度优先遍历使用栈来实现，因此它是一种先进后出（Last In First Out，LIFO）的算法。 下面是邻接矩阵的深度优先遍历的Python代码示例： ```python def DFS(graph, start): visited = set() # 用集合来存储已经访问过的节点 stack = [start] # 用列表来模拟栈 while stack: vertex = stack.pop() # 取出栈顶元素 if vertex not in visited: visited.add(vertex) # 标记为已访问 print(vertex, end=' ') # 将未访问的邻居节点入栈 stack.extend([i for i in range(len(graph[vertex])) if graph[vertex][i] and i not in visited]) # 示例 graph = [[0, 1, 1, 0], [1, 0, 0, 1], [1, 0, 0, 1], [0, 1, 1, 0]] DFS(graph, 0) # 输出：0 1 3 2 ``` 邻接矩阵的广度优先遍历（Breadth First Search，BFS）： 广度优先遍历是一种用于遍历或搜索树或图的算法。在这个算法中，首先访问根节点，然后逐层访问每个子节点。当访问一个节点时，将其标记为已访问，以避免重复访问。广度优先遍历使用队列来实现，因此它是一种先进先出（First In First Out，FIFO）的算法。 下面是邻接矩阵的广度优先遍历的Python代码示例： ```python from collections import deque def BFS(graph, start): visited = set() # 用集合来存储已经访问过的节点 queue = deque([start]) # 用双端队列来模拟队列 while queue: vertex = queue.popleft() # 取出队首元素 if vertex not in visited: visited.add(vertex) # 标记为已访问 print(vertex, end=' ') # 将未访问的邻居节点入队 queue.extend([i for i in range(len(graph[vertex])) if graph[vertex][i] and i not in visited]) # 示例 graph = [[0, 1, 1, 0], [1, 0, 0, 1], [1, 0, 0, 1], [0, 1, 1, 0]] BFS(graph, 0) # 输出：0 1 2 3 ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值