图的宽度优先遍历

最新推荐文章于 2024-09-10 19:40:29 发布
最新推荐文章于 2024-09-10 19:40:29 发布
阅读量2.2k 收藏
点赞数 1
分类专栏： 算法集 文章标签： 宽度优先遍历 无向图 邻接矩阵 图遍历 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55599629/article/details/120112156
版权

读入一个用邻接矩阵存储的无向图，输出它的宽度优先遍历序列。 

输入

第 1 行 1 个正整数 n，表示图中顶点数，2≤n≤100； 

接下来的 n 行是一个 n×n 的邻接矩阵，a[i][j]=1 表示顶点 i 和顶点 j 之间有直接边相连，a[i][j]=0 表示没有直接边相连。保证 i=j 时，a[i][j]=0，并且 a[i][j]=a[j][i]。 

输出

输出 1~n 的某一种排列，表示从顶点 1 开始，对该图进行宽度优先遍历得到的顶点序列，每两个数之间用一个“-”分隔。

输入

8
0 1 1 0 0 0 0 0
1 0 0 1 1 0 0 0
1 0 0 0 0 0 1 1
0 1 0 0 0 1 0 0
0 1 0 0 0 1 0 0
0 0 0 1 1 0 0 0
0 0 1 0 0 0 0 1
0 0 1 0 0 0 1 0

输出

1-2-3-4-5-7-8-6

思路：

节点不重复遍历！为什么要管图连不连通呢？为什么不能一起考虑呢？

图所示为图的宽度优先遍历。 

用队列来实现图的宽度优先遍历： 

先从某个顶点出发，把这个顶点入队，作为队首元素。然后把跟队首元素相连的顶点再依次入队，最后队首元素出队。接着再把新的队首元素相连的所有顶点入队，新的队首元素出队。……如此下去，直到所有元素都出队，出队的顺序就是图的宽度优先遍历序列。

CODE：


                

        

        

    

  


        

            

                    
                      最低0.47元/天 解锁文章
                        
                    
            

        

    

      

        

            

              
                
                  xiedongbiao
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
图的遍历——深度优先搜索和广度（宽度）优先搜索（含例题）

				
			

			

				

					黑色吊椅的博客
				

				

					02-01
					
					3万+
					
				

			

		

		

			
				
专栏导读及目录https://blog.csdn.net/createprogram/article/details/86741044

深度优先搜索

DFS基本思想

基本步骤：

1.从图中某个顶点v0出发，首先访问v0;  

2.访问结点v0的第一个邻接点，以这个邻接点vt作为一个新节点，访问vt所有邻接点。直到以vt出发的所有节点都被访问到，回溯到v0的下一个未被访问过的邻接点，以这个...

			
		

	



                

            
              



	

		

			

				
					
图的宽度优先遍历：BFS遍历

				
			

			

				

					weixin_46838716的博客
				

				

					05-09
					
					2002
					
				

			

		

		

			
				
1）图的统一数据结构，丰富图结构表示法，要熟悉，就是一堆节点，一堆边，但是他们的属性很丰富，还有标准的构图过程
2）图的宽度优先遍历方法：BFS非常简单，就是沿着x的直接邻居，加入队列就行，弹出打印，不断加队列，很简单。
3）笔试求AC，可以不考虑空间复杂度，但是面试既要考虑时间复杂度最优，也要考虑空间复杂度最优。

			
		

	



              


  
              

                


	

		

			

				
					
算法【宽度优先遍历及其扩展】

					
最新发布

				
			

			

				

					W_O_Z的博客
				

				

					09-10
					
					963
					
				

			

		

		

			
				
宽度优先遍历基本内容1.bfs的特点是逐层扩散，从源头点到目标点扩散了几层，最短路就是多少。2.bfs可以使用的特征是任意两个节点之间的相互距离相同（无向图）。3.bfs开始时，可以是单个源头、也可以是多个源头。4.bfs频繁使用队列，形式可以是单点弹出或者整层弹出。5.bfs进行时，进入队列的节点需要标记状态，防止同一个节点重复进出队列。6.bfs进行时，可能会包含剪枝策略的设计。7.bfs是一个理解难度很低的算法，难点在于节点如何找到路、路的展开和剪枝设计。

			
		

	





	

		

			

				
					
头歌（C语言）-数据结构与算法-图（共2关）

				
			

			

				

					weixin_59436900的博客
				

				

					05-04
					
					5732
					
				

			

		

		

			
				
图 2 给出了对图 1 的无向图的存储结构图：每个顶点的名称由一个字符串描述，所有字符串的起始地址组织为一个数组，数组的起始地址为。图 2 给出了对图 1 的无向图的存储结构图：每个顶点的名称由一个字符串描述，所有字符串的起始地址组织为一个数组，数组的起始地址为。深度优先遍历的顶点访问次序是：ABDCFE。以下是平台对 step1/Main.cpp 的测试样例： 样例输入。宽度优先遍历的顶点访问次序是：A B C F D E。输出格式： 输出生成树的边序列，边的第。输出格式： 输出生成树的边序列，边的第。

			
		

	



		

			
		



	

		

			

				
					
图——宽度优先遍历

				
			

			

				

					Go的全部
				

				

					10-28
					
					377
					
				

			

		

		

			
				
package Graph

import (
	queue "Algorithm/Container"
	"fmt"
	"testing"
)

func bfs(node *Node) {

	if node == nil {
		return
	}

	queue := queue.NewQueue()
	set := make(map[*Node]struct{}) //可能有环，所以加上他把环避开
	queue.Push(node)
	set[node] = struct{}{}
	for !qu

			
		

	





	

		

			

				
					
educoder数据结构与算法 图 第1关：实现图的宽度优先遍历

					
热门推荐

				
			

			

				

					qq_54008392的博客
				

				

					12-09
					
					1万+
					
				

			

		

		

			
				
任务描述

本关任务：请你实现 graph.cpp 里的int Graph_WidthFirst(Graph*g, int start, Edge* tree)函数。 注意遵守约定：编号小的优先入队列。

相关知识





图 2 给出了对图 1 的无向图的存储结构图：每个顶点的名称由一个字符串描述，所有字符串的起始地址组织为一个数组，数组的起始地址为vetex；顶点的相邻关系保存在相邻矩阵中，其起始地址为adj，adj[i*n+j]的值为 1 表示i号顶点到j号顶点有边，为 0 表示无边，其中n是顶点个

			
		

	





	

		

			

				
					
1048-图的宽度优先遍历序列

				
			

			

				

					weixin_30650039的博客
				

				

					11-21
					
					157
					
				

			

		

		

			
				
描述

图(graph)是数据结构 G=(V,E)，其中V是G中结点的有限非空集合,结点的偶对称为边(edge)；E是G中边的有限集合。设V={0,1,2,……,n-1}，图中的结点又称为顶点(vertex)，有向图(directed graph)指图中代表边的偶对是有序的，用<u，v>代表一条有向边（又称为弧），则u称为该边的始点（尾），v称为边的终点（头）。无向图(undir...

			
		

	





	

		

			

				
					
图的宽度优先遍历非递归实现——C++

				
			

			

				

					weixin_43011522的博客
				

				

					09-05
					
					1576
					
				

			

		

		

			
				
思路： 
          用队列实现图的非递归BFS。首先把遍历起始顶点push进队列；然后每次从队列中pop一个顶点时，都遍历此顶点，并遍历边表，找出与此顶点相连接的顶点，若此连接顶点未被访问，则入队，若此顶点已被访问，则继续，直到队列为空，深度遍历结束。

注意：深度遍历图时，所有顶点被访问到的前提条件为此图为连通图。

代码：

#include &amp;amp;amp;lt;iostream&amp;amp;amp;gt;
#in...

			
		

	





	

		

			

				
					
图的深度优先遍历与广度优先遍历(C语言实现)

				
			

			

				

					10-17
				

			

		

		

			
				
数据结构中的图结构，其中最重要的两个遍历算法——深度优先遍历与广度优先遍历

			
		

	





	

		

			

				
					
图的宽度优先遍历（拓扑序列）

				
			

			

				

					cfscsdn的博客
				

				

					01-03
					
					313
					
				

			

		

		

			
				
拓扑队列（宽度优先遍历的应用）

			
		

	





	

		

			

				
					
算法学习：图的宽度优先遍历（BFS）

				
			

			

				

					zkyrjsxdm的博客
				

				

					12-13
					
					2926
					
				

			

		

		

			
				
图的宽度优先遍历早就学过宽度优先遍历，也自以为会了，今天一写程序才知道自己之前的理解有很多不对的地方，这里就不详细说了。宽度优先算法思想：从一个点开始，检查与这个点相连的点，如果没有被访问过，则放到待访问队列中，否则跳过。直到待访问队列为空。C++中队列的使用： 
头文件包含<queue> 
几个本文用到的操作：push(i):将i放到队列中，入队
pop(i):将点i从队列中删除
q.front(

			
		

	





	

		

			

				
					
1048 图的宽度优先遍历序列 c语言

				
			

			

				

					diaoyuan6818的博客
				

				

					02-24
					
					388
					
				

			

		

		

			
				
描述

图(graph)是数据结构G=(V,E)，其中V是G中结点的有限非空集合,结点的偶对称为边(edge)；E是G中边的有限集合。设V={0,1,2,……,n-1}，图中的结点又称为顶点(vertex)，有向图(directed graph)指图中代表边的偶对是有序的，用<u，v>代表一条有向边（又称为弧），则u称为该边的始点（尾），v称为边的终点（头）。无向图(...

			
		

	





	

		

			

				
					
图的遍历：宽度优先遍历

				
			

			

				

					长风的专栏
				

				

					04-03
					
					3402
					
				

			

		

		

			
				
/*
	图的遍历：宽度优先遍历
	队列
	2014-4-3 09:14:41
*/

/*
	测试数据
9 12
5 8 29
6 1 12
8 3 11
1 2 4
3 1 22
4 3 17
7 4 25
6 5 9
8 7 7
1 6 9
3 2 19
6 7 4

*/

#include 
#include 
#define MAX 10000
using namespace std;


			
		

	





	

		

			

				
					
图的广度优先遍历算法

				
			

			

				

					weixin_34110749的博客
				

				

					12-23
					
					710
					
				

			

		

		

			
				
前言

广度优先遍历算法是图的另一种基本遍历算法，其基本思想是尽最大程度辐射能够覆盖的节点，并对其进行访问。以迷宫为例，深度优先搜索更像是一个人在走迷宫，遇到没有走过就标记，遇到走过就退一步重新走；而广度优先搜索则可以想象成一组人一起朝不同的方向走迷宫，当出现新的未走过的路的时候，可以理解成一个人有分身术，继续从不同的方向走，，当相遇的...

			
		

	





	

		

			

				
					
图的深度优先遍历和宽度优先遍历

				
			

			

				

					11-27
				

			

		

		

			
				
以下是图的深度优先遍历和宽度优先遍历的介绍：

深度优先遍历（DFS）：
深度优先遍历是一种用于遍历或搜索树或图的算法。在这种搜索方法中，从根结点开始，尽可能深地搜索每个分支，直到到达最深的结点，然后回溯到前一个结点，继续搜索另一个分支，直到所有结点都被访问为止。深度优先遍历使用栈来实现，因此也称为“栈搜索”。

以下是深度优先遍历的Python代码示例：

```python
# Python3 program to print DFS traversal
# from a given given graph
from collections import defaultdict
 
# This class represents a directed graph using
# adjacency list representation
class Graph:
 
    # Constructor
    def __init__(self):
 
        # default dictionary to store graph
        self.graph = defaultdict(list)
 
    # function to add an edge to graph
    def addEdge(self, u, v):
        self.graph[u].append(v)
 
    # A function used by DFS
    def DFSUtil(self, v, visited):
 
        # Mark the current node as visited
        # and print it
        visited.add(v)
        print(v, end=' ')
 
        # Recur for all the vertices
        # adjacent to this vertex
        for neighbour in self.graph[v]:
            if neighbour not in visited:
                self.DFSUtil(neighbour, visited)
 
    # The function to do DFS traversal. It uses
    # recursive DFSUtil()
    def DFS(self, v):
 
        # Create a set to store visited vertices
        visited = set()
 
        # Call the recursive helper function
        # to print DFS traversal
        self.DFSUtil(v, visited)
```

宽度优先遍历（BFS）：
宽度优先遍历是一种用于遍历或搜索树或图的算法。在这种搜索方法中，从根结点开始，逐层遍历每个结点的所有子结点，直到到达最深的结点。宽度优先遍历使用队列来实现。

以下是宽度优先遍历的Python代码示例：

```python
# Python3 program to print BFS traversal
# from a given source vertex. BFS(int s)
# traverses vertices reachable from s.
from collections import defaultdict
 
# This class represents a directed graph
# using adjacency list representation
class Graph:
 
    # Constructor
    def __init__(self):
 
        # default dictionary to store graph
        self.graph = defaultdict(list)
 
    # function to add an edge to graph
    def addEdge(self, u, v):
        self.graph[u].append(v)
 
    # Function to print a BFS of graph
    def BFS(self, s):
 
        # Mark all the vertices as not visited
        visited = [False] * (max(self.graph) + 1)
 
        # Create a queue for BFS
        queue = []
 
        # Mark the source node as
        # visited and enqueue it
        queue.append(s)
        visited[s] = True
 
        while queue:
 
            # Dequeue a vertex from
            # queue and print it
            s = queue.pop(0)
            print(s, end=" ")
 
            # Get all adjacent vertices of the
            # dequeued vertex s. If a adjacent
            # has not been visited, then mark it
            # visited and enqueue it
            for i in self.graph[s]:
                if visited[i] == False:
                    queue.append(i)
                    visited[i] = True
```



			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值