【经典算法实现 36】图的最短路径计算（广度优先遍历法 和 深度优先遍历法）

最新推荐文章于 2025-03-22 12:06:01 发布
最新推荐文章于 2025-03-22 12:06:01 发布
阅读量6k 收藏 30
点赞数 7
分类专栏： 数据结构与算法 # 图 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，禁止转载。
本文链接：https://blog.csdn.net/ciellee/article/details/108219662
版权
本文介绍了使用广度优先遍历和深度优先遍历算法计算图的最短路径的方法，详细解释了算法的实现思路，并提供了完整的代码示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

【经典算法实现 36】图的最短路径计算（广度优先遍历法 和 深度优先遍历法）

本文接着前文，如果对网的创建、深度优先遍历算法或广度优先遍历算法 有疑问的同学，可参考下前文：

《【经典算法实现 33】图的创建 — 有向邻接矩阵法 与 网》
《【经典算法实现 34】带权有向邻接矩阵（网的遍历）— 深度优先遍历算法》
《【经典算法实现 35】带权有向邻接矩阵（网的遍历）— 广度优先遍历算法》


老样子，先上图：

在这里插入图片描述
问题来了，请计算从 A 到 G 的最短路径。
我们看得出来有很多条路径，比如 A->B->D->E->G 或 A-C->D->E->G ，到度哪条最短呢?

这个该怎么实现呢?
答:
最短路很多六种方法：

  1. 广度优先算法
  2. 深度优先算法
  3. 弗洛伊德算法
  4. 迪杰斯特拉算法
  5. Bellman-Ford算法
  6. SPFA(Shortest Path Faster Algorithm)

本文目前讲前两种方法：广度优先算法，深度优先算法


一、最短路径算法

1.1 通过广度 / 深度优先 实现思路

广度 / 深度 优先遍历算法，实现了让我们能够不重复的访问到图上的每一个结点。

最短路径算法实现思路（默认以A 为起点）：

  1. 创建一个二维数组保存某个节点到A的距离，比如{'A', 0}，说明'A' 到'A' 的最短路径为 0
  2. 在每次遍历节点时，都计算一下上个节点到当前节点的距离，加上上个节点到A的最短路径，如果存在更短，则更新数组

1.2 广度优先遍历实现计算最短路径代码

// 网矩阵广度遍历算法 
void BFS_Matrix()
{
	char cur, next; 
	char find_list[Node_Num], *f = find_list, i, j;

	// 分配二级指针内存，用于保存最短路径，及父节点 
	// sh[0]: 要求最短路径的节点
	// sh[1]: 前一个节点
	// sh[2]: 当前到A的最短距离 
	int **sh =  (int **)malloc(sizeof(int *) * Node_Num);
	for(i = 0; i<Node_Num; i++){
		*(sh+i) = (int *)malloc(sizeof(int) * 3);
		(*(sh+i))[0] = 0;
		(*(sh+i))[1] = 0;
		(*(sh+i))[2] = INT_MAX;	// 初始距离是最大 
	}
	// 先将 'A' 入队列 
	Push_Node(pNode[0]);
	*f++ = pNode[0];	// 记录 A 已访问过 
	sh[0][0] = pNode[0];
	sh[0][1] = pNode[0];
	
	// 只要栈头指针指向的数据不为0，说明队列 不为空 
	while(list_head->node != 0){
		cur = Pop_Queue();	// 出队列 
		
		// 找到下一个未访问过的节点
		for(i =0; i<Node_Num ; i++){
			if( sNode[cur-'A'][i] > 0){
				next = 'A' + i;
				printf("\n当前%c->%c = %d",cur, next, sNode[cur-'A'][i]);
				// 找到节点，判断新节点是否访问过，如果没访问过就放入队列 
				for(j=0; j<Node_Num; j++){
					if(find_list[j] == next)
						break;
					
		 			// 如果到最后一个还不匹配，说明没访问过 
		 			if(  j == Node_Num-1){
		 				Push_Node(next);
						*f++ = next;	// 记录 next已访问过 
			 		}
			 	}
		 		printf("\n当前节点%c 的距离 %d, 父节点%c 最短距离：%d\n", next, sNode[cur-'A'][next-'A'],cur,  sh[cur-'A'][2]);
		 		// 更新最短路径 =  sh[cur-'A'][2] + sNode[cur-'A'][next-'A']
		 		if(next != 'A'){
		 			if( sh[cur-'A'][2] == INT_MAX ){
						sh[next-'A'][0] = next;
						sh[next-'A'][1] = cur;
						sh[next-'A'][2] = sNode[cur-'A'][next-'A'];
					}else if(sNode[cur-'A'][next-'A'] + sh[cur-'A'][2] < sh[next-'A'][2]){
							sh[next-'A'][0] = next;
							sh[next-'A'][1] = cur;	
							sh[next-'A'][2] = sNode[cur-'A'][next-'A'] + sh[cur-'A'][2];
					}
		 		}
			}
		}
	}
	printf("\n\n网矩阵广度遍历结束, 遍历顺序为：\n");
	for(i=0; i<Node_Num; i++)
		printf("%c--> ", find_list[i]); 
	printf("\n\n"); 

	printf("\n\n最短距离为：\n");
	for(i=0; i<Node_Num; i++)
		printf("当前结点：%c，父结点：%c， 当前到'A'最短距离：%d\n", sh[i][0], sh[i][1], sh[i][2]==INT_MAX?0:sh[i][2]); 
	printf("\n\n");
}

运行结果为：

New_List_Queue -- size=10
列表创建完毕
网矩阵创建完毕
    A   B   C   D   E   F   G
A   -1   5   1  -1  -1  -1  -1
B    5  -1  -1   1  -1  -1  -1
C   -1  -1  -1   3  -1  -1  -1
D   -1  -1  -1  -1   6   4  -1
E   -1  -1  -1  -1  -1  -1   1
F   -1  -1   2  -1  -1  -1  -1
G   -1  -1  -1  -1  -1  -1  -1

网矩阵打印完毕

插入元素 A, list_head(00A80DC0), list_tail(00A80DC0)
弹出元素 A
当前A->B = 5
插入元素 B, list_head(00A80DD8), list_tail(00A80DD8)
当前节点B 的距离 5, 父节点A 最短距离：65535

当前A->C = 1
插入元素 C, list_head(00A80DD8), list_tail(00A80DF0)
当前节点C 的距离 1, 父节点A 最短距离：65535

弹出元素 B
当前B->A = 5
当前节点A 的距离 5, 父节点B 最短距离：5

当前B->D = 1
插入元素 D, list_head(00A80DF0), list_tail(00A80E08)
当前节点D 的距离 1, 父节点B 最短距离：5

弹出元素 C
当前C->D = 3
当前节点D 的距离 3, 父节点C 最短距离：1

弹出元素 D
当前D->E = 6
插入元素 E, list_head(00A80E20), list_tail(00A80E20)
当前节点E 的距离 6, 父节点D 最短距离：4

当前D->F = 4
插入元素 F, list_head(00A80E20), list_tail(00A80E38)
当前节点F 的距离 4, 父节点D 最短距离：4

弹出元素 E
当前E->G = 1
插入元素 G, list_head(00A80E38), list_tail(00A80E50)
当前节点G 的距离 1, 父节点E 最短距离：10

弹出元素 F
当前F->C = 2
当前节点C 的距离 2, 父节点F 最短距离：8

弹出元素 G

网矩阵广度遍历结束, 遍历顺序为：
A--> B--> C--> D--> E--> F--> G-->

最短距离为：
当前结点：A，父结点：A， 当前到'A'最短距离：0
当前结点：B，父结点：A， 当前到'A'最短距离：5
当前结点：C，父结点：A， 当前到'A'最短距离：1
当前结点：D，父结点：C， 当前到'A'最短距离：4
当前结点：E，父结点：D， 当前到'A'最短距离：10
当前结点：F，父结点：D， 当前到'A'最短距离：8
当前结点：G，父结点：E， 当前到'A'最短距离：11

1.3 深度优先遍历实现计算最短路径代码

// 网矩阵深度遍历算法 
void DFS_Matrix()
{
	char cur, next; 
	char find_list[Node_Num], *f = find_list, flag, i, j;
	
	// 分配二级指针内存，用于保存最短路径，及父节点 
	int **sh =  (int **)malloc(sizeof(int *) * Node_Num);
	for(i = 0; i<Node_Num; i++){
		*(sh+i) = (int *)malloc(sizeof(int) * 3);
		(*(sh+i))[0] = 0;
		(*(sh+i))[1] = 0;
		(*(sh+i))[2] = INT_MAX;	// 初始距离是最大 
	}
	
	// 先将 'A' 入栈
	Push_Node(pNode[0]);
	*f++ = pNode[0];	// 记录 A 已访问过 
	sh[0][0] = pNode[0];
	sh[0][1] = pNode[0];
	
	// 只要栈头指针指向的数据不为0，说明栈不为空 
	while(list_head->node != 0){
		cur = Pop_Stack();	// 出栈
		// 找到下一个未访问过的节点
		for(i =0, flag=0; i<Node_Num && flag==0; i++){
			if( sNode[cur-'A'][i] > 0){
				next = 'A' + i;
				//printf("\n当前%c->%c = %d, flag=%d",cur, next, sNode[cur-'A'][i], flag);
				// 找到节点，判断新节点是否访问过，如果访问过返回1 
				for(j=0; j<Node_Num && flag==0; j++){
			 		if(find_list[j] == next){
		 				break;
		 			}
		 			if(j == Node_Num-1)
		 				flag = 1;
			 	}		
			}
		}
	 	if(flag == 1){
	 		Push_Node(cur);		// 将当前节点入栈 
	 		Push_Node(next);	// 将新节点入栈 
	 		*f++ = next;	    // 记新节点已访问过 
	 		
	 		printf("\n当前节点%c 的距离 %d, 父节点%c 最短距离：%d\n", next, sNode[cur-'A'][next-'A'],cur,  sh[cur-'A'][2]);
	 	}else
	 		printf(", 未找到有效节点，跳过",cur);
	 		
	 	//针对当前节点，遍历所有可连接的点 
		for( i=0;  i<Node_Num; i++){
			if( sNode[cur-'A'][i] > 0){
				next = 'A' + i;
				if(next != 'A'){
	 			if( sh[cur-'A'][2] == INT_MAX ){
						sh[next-'A'][0] = next;
						sh[next-'A'][1] = cur;
						sh[next-'A'][2] = sNode[cur-'A'][next-'A'];
					}else if(sNode[cur-'A'][next-'A'] + sh[cur-'A'][2] < sh[next-'A'][2]){
							sh[next-'A'][0] = next;
							sh[next-'A'][1] = cur;	
							sh[next-'A'][2] = sNode[cur-'A'][next-'A'] + sh[cur-'A'][2];
					}
				 	
		 		}
			}
		}
	
		
	}
	printf("\n\n网矩阵深度遍历结束, 遍历顺序为：\n");
	for(i=0; i<Node_Num; i++)
		printf("%c--> ", find_list[i]); 
	printf("\n\n"); 
	
	printf("\n\n最短距离为：\n");
	for(i=0; i<Node_Num; i++)
		printf("当前结点：%c，父结点：%c， 当前到'A'最短距离：%d\n", sh[i][0], sh[i][1], sh[i][2]==INT_MAX?0:sh[i][2]); 
	printf("\n\n");
}

运行结果为：

New_List_Queue -- size=10
列表创建完毕
网矩阵创建完毕
    A   B   C   D   E   F   G
A   -1   5   1  -1  -1  -1  -1
B    5  -1  -1   1  -1  -1  -1
C   -1  -1  -1   3  -1  -1  -1
D   -1  -1  -1  -1   6   4  -1
E   -1  -1  -1  -1  -1  -1   1
F   -1  -1   2  -1  -1  -1  -1
G   -1  -1  -1  -1  -1  -1  -1

网矩阵打印完毕

插入元素 A, list_head(006C0DC0), list_tail(006C0DC0)
弹出元素 A
插入元素 A, list_head(006C0DC0), list_tail(006C0DC0)
插入元素 B, list_head(006C0DC0), list_tail(006C0DD8)
当前节点B 的距离 5, 父节点A 最短距离：65535

弹出元素 B
插入元素 B, list_head(006C0DC0), list_tail(006C0DD8)
插入元素 D, list_head(006C0DC0), list_tail(006C0DF0)
当前节点D 的距离 1, 父节点B 最短距离：5

弹出元素 D
插入元素 D, list_head(006C0DC0), list_tail(006C0DF0)
插入元素 E, list_head(006C0DC0), list_tail(006C0E08)
当前节点E 的距离 6, 父节点D 最短距离：6

弹出元素 E
插入元素 E, list_head(006C0DC0), list_tail(006C0E08)
插入元素 G, list_head(006C0DC0), list_tail(006C0E20)
当前节点G 的距离 1, 父节点E 最短距离：12

弹出元素 G, 未找到有效节点，跳过
弹出元素 E, 未找到有效节点，跳过
弹出元素 D
插入元素 D, list_head(006C0DC0), list_tail(006C0DF0)
插入元素 F, list_head(006C0DC0), list_tail(006C0E08)
当前节点F 的距离 4, 父节点D 最短距离：6

弹出元素 F
插入元素 F, list_head(006C0DC0), list_tail(006C0E08)
插入元素 C, list_head(006C0DC0), list_tail(006C0E20)
当前节点C 的距离 2, 父节点F 最短距离：10

弹出元素 C, 未找到有效节点，跳过
弹出元素 F, 未找到有效节点，跳过
弹出元素 D, 未找到有效节点，跳过
弹出元素 B, 未找到有效节点，跳过
弹出元素 A, 未找到有效节点，跳过

网矩阵深度遍历结束, 遍历顺序为：
A--> B--> D--> E--> G--> F--> C-->

最短距离为：
当前结点：A，父结点：A， 当前到'A'最短距离：0
当前结点：B，父结点：A， 当前到'A'最短距离：5
当前结点：C，父结点：A， 当前到'A'最短距离：1
当前结点：D，父结点：C， 当前到'A'最短距离：4
当前结点：E，父结点：D， 当前到'A'最短距离：10
当前结点：F，父结点：D， 当前到'A'最短距离：8
当前结点：G，父结点：E， 当前到'A'最短距离：13

二、完整代码

/*	
横轴为：终点   纵轴为：起始点 
A->B D->C 在数组中存储为sNode[A][B]，sNode[D][C]
  \	A  B  C  D
 A	0  1  0  0
 B	0  0  0  0
 C	0  0  0  0
 D	0  0  1  0
*/

#include <stdio.h>
 
#define Node_Num  7												// 顶点的数量
char pNode[Node_Num]={'A', 'B', 'C', 'D', 'E', 'F', 'G'};		// 用于保存顶点的值
int sNode[Node_Num][Node_Num];									// 用于表示各边的关系

#define INT_MAX   65535

#define sNode_Num  	9			// 9条边 
const int s_char[sNode_Num][3]={ 
				{'A','B', 5}, 	{'A','C', 1}, 
				{'B','D', 1}, 	{'B','A', 5}, 
				{'C','D', 3}, 
				{'D','E', 6},   {'D','F', 4}, 
				{'E','G', 1}, 
				{'F','C', 2}};
void Create_Matrix()
{
	int i = 0, start, end;
	memset(sNode, INT_MAX, sizeof(sNode));	//初始化所有边为最大 
	
	for(i = 0; i<sNode_Num; i++){
		// 获取当前边的起始点
		start = s_char[i][0] - 'A';
		end = s_char[i][1] - 'A'; 
		sNode[start][end] = s_char[i][2];
	}
	printf("\n网矩阵创建完毕\n\n");
} 

void Print_Matrix(void)
{
	int start,end;
	printf("    ");
	for(start = 0; start<Node_Num; start++) 
		printf("%c   ", pNode[start]);
		
	for(start = 0; start<Node_Num; start++){
		printf("\n%c   ", pNode[start]);
		for(end = 0; end<Node_Num; end++){
			printf("%2d  ", sNode[start][end]);
		}
	}
	printf("\n\n网矩阵打印完毕\n");	
}

// 栈代码 *********************************************************************** 
// 实现一个 10 个元素的循环队列 
#define Queue_Size  10
typedef struct List{
	char node;
	struct List *next;
	struct List *pre;
}List;

// 定义循环队列的头部和尾部 
List * list_head = NULL;
List * list_tail = NULL;

// 往list后添加新的节点，list为队尾节点 
List * Insert_pNode(List *list){
	List *p;
	if(list ==  NULL){
		return NULL;
	}
	p = (List *)malloc(sizeof(List));
	p->node = 0;
	p->next = list->next;
	p->pre = list->next->pre;
	list->next->pre = p; 
	list->next = p;
	return p; 
}

List * New_List_Queue(int size){
	List * list;
	int i; 
	if(size == 0)
		return NULL;
	
	printf("\n%s -- size=%d\n",__func__, size);
	
	// 创建头节点，单向循环链表头节点指向自已 
	list = (List *)malloc(sizeof(List));

	list->node = 0;
	list->next = list;
	list->pre = list;
	list_head = list;	//队头指向 list
	list_tail = list;	//队尾指向 list 

	//创建剩余的节点
	for(i = 0; i<size-1; i++){
		list = Insert_pNode(list);
	}
	printf("\n列表创建完毕\n");
	//创建完毕，返回list 的头结点，即 list->next，因为list即最后一个节点
	return list->next; 
} 

void Delete_List_Queue(List *list){
	List *p;
	while(list->next != list){
		p = list->next;
		list->next = p->next;
		list->next->pre = p->pre;
		printf("\n释放ListQueue：%p", p);
		free(p);
	}
	printf("\n释放ListQueue：%p\n\n", list);
	free(list);
}

//向队尾指针添加  Node节点 
void Push_Node(char node){
	List *p = NULL;
	
	// 如果队列满了，则自动扩充队列
	if(list_tail == list_head && list_head->node != 0){
		// 找到list_head 的前一个节点
		p = list_head;
		while(p->next != list_head) p = p->next; 
		// 在队尾插入节点，返回队尾指针 
		list_tail = Insert_pNode(p);
		printf("\n队列容量已满，增加一个元素, list_tail=%p, list_head=%p\n", list_tail, list_head); 
	} 
	
	if(list_tail != NULL){
		printf("\n插入元素 %c, list_head(%p), list_tail(%p)",node, list_head,list_tail );
		list_tail->node = node;
		list_tail = list_tail->next;
	}
}

//队列：从队头取出一个 Node节点，队列无数据时，返回NULL，即先进先出 
char Pop_Queue(){
	char node;
	if(list_head != NULL && list_head->node != 0){
		node = list_head->node;
		list_head->node  = 0;
		list_head = list_head->next;
		printf("\n弹出元素 %c",node); 
		return node;
	}
	return 0;
} 

//栈: 从队尾取出一个 Node节点，队列无数据时，返回NULL，即先进后出 
char Pop_Stack(){
	char node;
	if(list_tail->pre != NULL && list_tail->pre->node != 0){
		node = list_tail->pre->node;
		list_tail->pre->node = 0;
		list_tail = list_tail->pre; 
		printf("\n弹出元素 %c",node); 
		return node;
	}
	return 0;
} 

// 网矩阵深度遍历算法 
void DFS_Matrix()
{
	char cur, next; 
	char find_list[Node_Num], *f = find_list, flag, i, j;
	
	// 分配二级指针内存，用于保存最短路径，及父节点 
	int **sh =  (int **)malloc(sizeof(int *) * Node_Num);
	for(i = 0; i<Node_Num; i++){
		*(sh+i) = (int *)malloc(sizeof(int) * 3);
		(*(sh+i))[0] = 0;
		(*(sh+i))[1] = 0;
		(*(sh+i))[2] = INT_MAX;	// 初始距离是最大 
	}
	
	// 先将 'A' 入栈
	Push_Node(pNode[0]);
	*f++ = pNode[0];	// 记录 A 已访问过 
	sh[0][0] = pNode[0];
	sh[0][1] = pNode[0];
	
	// 只要栈头指针指向的数据不为0，说明栈不为空 
	while(list_head->node != 0){
		cur = Pop_Stack();	// 出栈
		// 找到下一个未访问过的节点
		for(i =0, flag=0; i<Node_Num && flag==0; i++){
			if( sNode[cur-'A'][i] > 0){
				next = 'A' + i;
				//printf("\n当前%c->%c = %d, flag=%d",cur, next, sNode[cur-'A'][i], flag);
				// 找到节点，判断新节点是否访问过，如果访问过返回1 
				for(j=0; j<Node_Num && flag==0; j++){
			 		if(find_list[j] == next){
		 				break;
		 			}
		 			if(j == Node_Num-1)
		 				flag = 1;
			 	}		
			}
		}
	 	if(flag == 1){
	 		Push_Node(cur);		// 将当前节点入栈 
	 		Push_Node(next);	// 将新节点入栈 
	 		*f++ = next;	    // 记新节点已访问过 
	 		
	 		printf("\n当前节点%c 的距离 %d, 父节点%c 最短距离：%d\n", next, sNode[cur-'A'][next-'A'],cur,  sh[cur-'A'][2]);
	 	}else
	 		printf(", 未找到有效节点，跳过",cur);
	 		
	 	//针对当前节点，遍历所有可连接的点 
		for( i=0;  i<Node_Num; i++){
			if( sNode[cur-'A'][i] > 0){
				next = 'A' + i;
				if(next != 'A'){
	 			if( sh[cur-'A'][2] == INT_MAX ){
						sh[next-'A'][0] = next;
						sh[next-'A'][1] = cur;
						sh[next-'A'][2] = sNode[cur-'A'][next-'A'];
					}else if(sNode[cur-'A'][next-'A'] + sh[cur-'A'][2] < sh[next-'A'][2]){
							sh[next-'A'][0] = next;
							sh[next-'A'][1] = cur;	
							sh[next-'A'][2] = sNode[cur-'A'][next-'A'] + sh[cur-'A'][2];
					}
				 	
		 		}
			}
		}
	}
	printf("\n\n网矩阵深度遍历结束, 遍历顺序为：\n");
	for(i=0; i<Node_Num; i++)
		printf("%c--> ", find_list[i]); 
	printf("\n\n"); 
	
	printf("\n\n最短距离为：\n");
	for(i=0; i<Node_Num; i++)
		printf("当前结点：%c，父结点：%c， 当前到'A'最短距离：%d\n", sh[i][0], sh[i][1], sh[i][2]==INT_MAX?0:sh[i][2]); 
	printf("\n\n");
}

// 网矩阵广度遍历算法 
void BFS_Matrix()
{
	char cur, next; 
	char find_list[Node_Num], *f = find_list, i, j;

	// 分配二级指针内存，用于保存最短路径，及父节点 
	int **sh =  (int **)malloc(sizeof(int *) * Node_Num);
	for(i = 0; i<Node_Num; i++){
		*(sh+i) = (int *)malloc(sizeof(int) * 3);
		(*(sh+i))[0] = 0;
		(*(sh+i))[1] = 0;
		(*(sh+i))[2] = INT_MAX;	// 初始距离是最大 
	}
	
	// 先将 'A' 入队列 
	Push_Node(pNode[0]);
	*f++ = pNode[0];	// 记录 A 已访问过 
	sh[0][0] = pNode[0];
	sh[0][1] = pNode[0];
	
	// 只要栈头指针指向的数据不为0，说明队列 不为空 
	while(list_head->node != 0){
		cur = Pop_Queue();	// 出队列 
		
		// 找到下一个未访问过的节点
		for(i =0; i<Node_Num ; i++){
			if( sNode[cur-'A'][i] > 0){
				next = 'A' + i;
				printf("\n当前%c->%c = %d",cur, next, sNode[cur-'A'][i]);
				// 找到节点，判断新节点是否访问过，如果没访问过就放入队列 
				for(j=0; j<Node_Num; j++){
					if(find_list[j] == next)
						break;
					
		 			// 如果到最后一个还不匹配，说明没访问过 
		 			if(  j == Node_Num-1){
		 				Push_Node(next);
						*f++ = next;	// 记录 next已访问过 
			 		}
			 	}
			 	
		 		printf("\n当前节点%c 的距离 %d, 父节点%c 最短距离：%d\n", next, sNode[cur-'A'][next-'A'],cur,  sh[cur-'A'][2]);
		 		// 更新最短路径 =  sh[cur-'A'][2] + sNode[cur-'A'][next-'A']
		 		if(next != 'A'){
		 			if( sh[cur-'A'][2] == INT_MAX ){
						sh[next-'A'][0] = next;
						sh[next-'A'][1] = cur;
						sh[next-'A'][2] = sNode[cur-'A'][next-'A'];
					}else if(sNode[cur-'A'][next-'A'] + sh[cur-'A'][2] < sh[next-'A'][2]){
							sh[next-'A'][0] = next;
							sh[next-'A'][1] = cur;	
							sh[next-'A'][2] = sNode[cur-'A'][next-'A'] + sh[cur-'A'][2];
					}
			 	
		 		}	
				
			}
		}
	}
	printf("\n\n网矩阵广度遍历结束, 遍历顺序为：\n");
	for(i=0; i<Node_Num; i++)
		printf("%c--> ", find_list[i]); 
	printf("\n\n"); 
	
	printf("\n\n最短距离为：\n");
	for(i=0; i<Node_Num; i++)
		printf("当前结点：%c，父结点：%c， 当前到'A'最短距离：%d\n", sh[i][0], sh[i][1], sh[i][2]==INT_MAX?0:sh[i][2]); 
	printf("\n\n");
}

int main()
{	
	// 初始化栈链表 
	List * list = New_List_Queue(Queue_Size);
	
	// 创建网矩阵 
	Create_Matrix();
	
	// 找印网矩阵
	Print_Matrix();
	
	// 网矩阵的深度遍历 
	//DFS_Matrix(); 
	// 网矩阵的广度遍历 
	BFS_Matrix();

	
	return 0;	 
}

《图的五种最短路径算法》

C语言实现广度优先搜索算法
2301_79326930的博客
09-05 548
广度优先搜索（BFS）是一种常用的图搜索算法，用于在图或树数据结构中找到从起点到目标节点的最短路径。通过以上的代码示例，你可以理解BFS算法的实现原理，并在自己的程序中应用该算法进行图搜索。函数实现了BFS算法的核心逻辑，通过循环遍历队列中的节点，并将其未访问的邻接节点加入队列，直到找到目标节点或遍历完整个图。BFS算法的基本思想是从起点开始，逐层地探索与当前节点相邻的节点，直到找到目标节点或遍历完整个图。函数中，我们首先从用户输入中获取图的节点数和边数，然后逐个添加边。函数将节点加入队列，
广度优先搜索求最短路径
kupePoem的专栏
05-30 1561
一、概述 宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。 二、广度优先搜索步骤 广度优先搜索使用队列（queue）来实现，过程如下 1、把根节点放...
最短路径算法之----广度优先
zl201lll的专栏
05-10 4703
 一些相互之间存在着链接关系的节点就构成了我们数据结构中所谓的图，也可称为网络。图其实是一些真实世界网络的拓朴描述，如实地再现了真实世界的一些网络特性。图有有向图、无向图、加权图、无权图、连通图和不连通图之分。（不是我们今天的重点，不再详细描述。） 在对许多网络的实际研究过程中，很多情况下，会涉及到对网络中两个节点间最短路径的研究。 如互联网中，一个IP报文，从源地址发出需要
图的广度优先遍历和最短路径算法
扬俊的小屋
09-12 2万+
目录 图的广度优先遍历和最短路径算法 前言 广度优先遍历算法的探讨 核心代码分析 测试用例 完整代码获取 博客文章版权声明 图的广度优先遍历和最短路径算法 前言 上一次，我们讨论了有关图的深度优先遍历算法，既然二叉树有深度遍历算法，图也有深度遍历算法。那么二叉树还有广度优先遍历算法，图又有没有广度优先算法呢？ 答...
数据结构——最短路径BFS算法
最新发布
2401_88135404的博客
03-22 420
从2号顶点开始，将第一个数组（d）值全部设置为无穷，第二个数组（path）全部设置为-1，再将二号结点的d的值设置为0(起始顶点)，再将visited数组中2号的值改为true。执行while循环，如果队列非空则弹出队列（2号），再从2号开始，找到与它相邻的所有顶点，如果其中有没有访问过的顶点，也就是visited值为false，则更改d++，再修改path，将2号结点填入，修改visited为true。设置两个数组，一个记录各个顶点到原始顶点的最短值，另一个记录每一个顶点在这各最短路径上的直接前驱。
BFS广度优先遍历寻找最短路径(超详细实现过程)
本人hexo博客：www.boluoboluobo.top
05-20 3万+
广度优先遍历寻找最短路径      最近想搞A*算法，发现有点没理解清楚。于是找到了广度优先遍历寻路算法学习了下，想看看可不可以对写A*有什么帮助。...
算法 -- 最短路径算法(广度优先搜索, WFS)
There is an octopus in the fish pond
08-24 917
找出从A到F的最短距离 dijkstra B B E E B->E D D B->D C C C->B C->D E->D F F E->F D->F A A A->B A->C 问题分析 由图可知， 算出此图的最短路径即最少边数。 A到F的最少边数即为最短路径。 适用于广度优先搜索算法。 实现思路 源码实现 python 实现 fr
广度优先搜索（BFS）寻找最短路径
mirrorboat的博客
01-22 1694
#include<iostream> using namespace std; void EnQueue(int i, int j, int k); //入队一个节点 void DeQueue(int* i, int* j, int* k); //获取当前节点的序号和对应的迷宫坐标，然后出列 int GetNextPos(int* i, int* j, int count); //得到下一个邻接点的位置 void ShortestPath_BFS(int i, int j); //广度优先遍.
用广度优先遍历求有向带权图的最短路径
wzh190015的博客
12-14 6586
用广度优先遍历求有向带权图的最短路径
数据结构中图的深度优先遍历算法与实现.pdf
08-07
深度优先遍历法通过尽可能深地向图的分支中前进，直到分支的末端，然后再回溯并探索下一条路径。 在深度优先遍历中，一般使用栈（Stack）这种数据结构来保存顶点的访问路径。算法开始时，首先将起始顶点放入栈中，...
直击高频编程考点：树相关知识及经典算法题总结
热门推荐
张彦峰的博客
10-27 3万+
树相关知识及编程练习总结：背景知识+树的应用举例（Spring中的应用举例+其他框架中的应用举例+实际开发中的应用举例）+相关编程练习（二叉树遍历：包括前序遍历、中序遍历、后序遍历、层序遍历等+二叉树的最大深度+二叉树的最小深度+对称二叉树+二叉树的最近公共祖先+二叉树的直径+二叉树的路径和+二叉搜索树中的插入操作+二叉搜索树中的删除操作+二叉搜索树中的搜索操作+二叉树的层平均值+二叉树的镜像+二叉树的序列化与反序列化+二叉树的右视图+二叉树的最大宽度+前序遍历和中序遍历构造二叉树+平衡二叉树）
matlab深度遍历算法,数据结构&算法之动态规划（深度优先遍历）
weixin_29331115的博客
03-22 1854
最近在看关于数据结构系列知识点，然后遇到一个动态规划相关的题目——邮票规划。首先先介绍下关于DPS，也就是深度优先遍历算法吧。深度优先遍历深度优先遍历，从初始访问结点出发，我们知道初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点。总结起来可以这样说：每次都在访问完当前结点后首先访问当前结点的第一个邻接结点...
数据结构深度优先和广度优先C语言
12-27
深度优先查找算法有点类似于前序遍历法，因为查找的过程也是遍历的过程，所以也习惯叫深度优先遍历。从图的某一顶点开始遍历，被访问过的顶点就做上已访问的记号，接着遍历此顶点的所有相邻且未访问过的顶点中的任意...
广度优先搜索(BFS)算法求解单源最短路径问题
_考不上研究生不改名的博客
03-14 5312
单源最短路径问题是图论中一类重要且常见的应用问题。在这个问题中，我们需要找到从一个给定源节点到其他节点的最短路径。广度优先搜索（BFS）算法是一种常用且有效的求解这一问题的算法。本篇博客将重点讨论单源最短路径问题及其实际应用，同时简要介绍BFS算法的基本思想。单源最短路径问题是指在一个权重图中，给定一个源节点（起点），需要找出从该源节点到其他所有节点的最短路径。其中，最短路径可能是指两个节点之间边的权重之和或边的数量。具体实例可以是在一个城市的地图中，找到从一个位置到另一个位置的最短路线；
广度优先搜索之最短路径
yang20141109的专栏
10-20 6527
广度优先搜索算法可以得到从已知源点到每个可达顶点的最短距离，此时的最短距离指的是路径上边的个数最少，使用parent数组记录当前顶点的父节点，比如parent[u] = v表示u的父节点为v。最短路径的长度记录在d数组中，比如d[v] = 3表示从源点(s)到v的最短路径为3。最后我们使用showPath()函数把最短路径输出。#include #include #include #include
利用广度优先遍历（BFS）计算最短路径——Java
诚朴求食
04-23 4832
今天看了数据结构中的图论，其中讲到求无向无权图的最短路径的方法，就是使用了广度优先遍历的方法进行求解。对照算法在Intellij IDEA上自己实现了一遍，下面把程序贴出来并进行一些解释。 首先我们要构建一个无向无权图，我要构建成如下所示的图。 然后我想计算出从North Gate到Canteen的最短路径，程序的输出结果应该为：North Gate, Square, Canteen ...
广度优先搜索(BFS)求解最短路径问题
ZYF__2015的博客
06-24 2642
广度优先搜索(BFS)求解最短路径问题 广度优先搜索算法思想 1.从起始点出发，先遍历下一层的所有结点，再遍历下下层的所有结点。（宽度优先） 2.在算法实现中，使用队列（先进先出）存储遍历的结点信息。 计算在网格中从原点到特定点的最短路径长度 Shortest Path in Binary Matrix(Medium) leetcode 由0，1构成的网格路径，0表示可以通过，1表示不可以通过。 import javafx.util.Pair; import java.util.LinkedList
算法Day6：广度优先搜索——最短路径问题
JohnnyLin
03-20 3823
BFS 思想： DFS的主要的思想就是一条路走到黑。例如：有N个阶段，第N个阶段走不通，就回退到第N-1个阶段尝试其他的可能。 而BFS维护的是一种层次关系，按照状态的层次扩展，先搜完走一步能到达的所有点，每次离根节点越近的越先扩展。 应用： 当要求最短路时，可以考虑用BFS（当然DFS在数据范围比较小的时候也OK），要求所有符合条件的情况时，考虑用DFS BFS，跟DFS差别不太大，还是由三个部...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小馋喵星人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值