图的领接矩阵和深度遍历

最新推荐文章于 2024-08-01 10:12:30 发布
最新推荐文章于 2024-08-01 10:12:30 发布
阅读量1.6k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Vw__c/article/details/51392675
本文介绍了如何使用C++实现图的邻接矩阵存储，并提供了深度优先遍历的算法。通过读取文件"data.txt"来构建无向图，然后展示领接矩阵并进行深度优先遍历。

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





#include"fstream"
#include"iostream"
using namespace std;
const int MaxInt = 32767;//表示极大值
const int MVNum = 100;//最大顶点数
typedef int Status;
bool visited[MVNum];
int i, j;
typedef struct {
<span style="white-space:pre">	</span>char vexs[MVNum]; //创建顶点表
<span style="white-space:pre">	</span>int arcs[MVNum][MVNum];//领接矩阵
<span style="white-space:pre">	</span>int vexnum, arcnum; //图的当前点数和边数


}AMGraph;
int LocateVex(AMGraph G, char v)//图的基本操作，寻找V的位置
{
<span style="white-space:pre">	</span>int i = 0;
<span style="white-space:pre">	</span>while (i < G.vexnum && v != G.vexs[i])
<span style="white-space:pre">		</span>i++;
<span style="white-space:pre">	</span>return i;
}
int CreateUDN(AMGraph &G) {
<span style="white-space:pre">	</span>char v1, v2; int w;
<span style="white-space:pre">	</span>fstream in;
<span style="white-space:pre">	</span>in.open("data.txt", ios::in);
<span style="white-space:pre">	</span>in >> G.vexnum;
<span style="white-space:pre">	</span>in >> G.arcnum;
<span style="white-space:pre">	</span>for (i = 0; i < G.vexnum; i++)//输入顶点表
<span style="white-space:pre">		</span>in >> G.vexs[i];//顶点表
<span style="white-space:pre">	</span>for (i = 0; i < G.vexnum; i++)
<span style="white-space:pre">		</span>for (j = 0; j < G.vexnum; j++)
<span style="white-space:pre">		</span>{
<span style="white-space:pre">		</span>G.arcs[i][j] = MaxInt;
<span style="white-space:pre">		</span>}
<span style="white-space:pre">	</span>for (int k = 0; k < G.arcnum; k++)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>//cout << "请输入该弧所依附的两个顶点和权值" << endl;
<span style="white-space:pre">		</span>in >> v1 >> v2 >> w;
<span style="white-space:pre">		</span>i = LocateVex(G, v1);
<span style="white-space:pre">		</span>j = LocateVex(G, v2);
<span style="white-space:pre">		</span>G.arcs[i][j] = w;
<span style="white-space:pre">		</span>G.arcs[j][i] = G.arcs[i][j];
<span style="white-space:pre">	</span>}
<span style="white-space:pre">	</span>in.close();


<span style="white-space:pre">	</span>//return 0;
<span style="white-space:pre">	</span>for (int n = 0; n < G.vexnum; n++)
<span style="white-space:pre">			</span>cout << G.vexs[n];
<span style="white-space:pre">	</span>
<span style="white-space:pre">	</span>cout << endl;
<span style="white-space:pre">	</span>cout << endl;
<span style="white-space:pre">	</span>cout << "该图的领接矩阵为" << endl;
<span style="white-space:pre">	</span>for (int x = 0; x < G.vexnum; x++)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>for (int y = 0; y < G.vexnum; y++)
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>if (G.arcs[x][y] != MaxInt)
<span style="white-space:pre">				</span>cout << G.arcs[x][y] << " ";
<span style="white-space:pre">			</span>else
<span style="white-space:pre">			</span>{
<span style="white-space:pre">				</span>cout << "    ";
<span style="white-space:pre">			</span>}
<span style="white-space:pre">		</span>}
<span style="white-space:pre">		</span>cout << endl;
<span style="white-space:pre">	</span>}
<span style="white-space:pre">	</span>return 0;
}<span style="white-space:pre">	</span>




void DFSM(AMGraph &G, int i)
{
<span style="white-space:pre">	</span>cout << "深度优先遍历结点：" << G.vexs[i] << endl;//访问顶vi
<span style="white-space:pre">	</span>visited[i] = true;
<span style="white-space:pre">	</span>for (int j = 0; j < G.vexnum; j++) //依次搜索vi邻接点
<span style="white-space:pre">		</span>if (!visited[j] && G.arcs[i][j] < MaxInt)
<span style="white-space:pre">			</span>DFSM(G, j);
}




void DFSTraverseM(AMGraph &G)
{
<span style="white-space:pre">	</span>int i;
<span style="white-space:pre">	</span>for (i = 0; i < G.vexnum; i++)
<span style="white-space:pre">		</span>visited[i] = false;
<span style="white-space:pre">	</span>for (i = 0; i < G.vexnum; i++)
<span style="white-space:pre">		</span>if (!visited[i])
<span style="white-space:pre">		</span>{
<span style="white-space:pre">		</span>DFSM(G, i);
<span style="white-space:pre">		</span>}
}


int main()
{
<span style="white-space:pre">	</span>AMGraph G;
<span style="white-space:pre">	</span>CreateUDN(G);
<span style="white-space:pre">	</span>DFSTraverseM(G);<span style="white-space:pre">			</span>//不连通
<span style="white-space:pre">	</span>return 0;
}









                

        

    

    
  



    



                



	

		

			

				
					
图的深度优先搜索-临接矩阵实现

				
			

			

				

					Limbos的博客
				

				

					11-28
					
					2680
					
				

			

		

		

			
				
1.问题描述：深度优先遍历

------假设给定图G的初态是所有顶点均未曾访问过。

       （1）在G中任选一顶点v为初始出发点，首先访问出发点v，并将其标记为已访问过；

       （2）然后依次从v出发搜索v的每个邻接点w。若w未曾访问过，则以w为新的出发点继续进行深度优先遍历，直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止。

			
		

	



                

            
              



	

		

			

				
					
领接矩阵结构的图的遍历（广度和深度遍历）

				
			

			

				

					Godzzb的博客
				

				

					04-10
					
					2315
					
				

			

		

		

			
				
最近在数据结构的学习中，学习到了图这一章节，在图中，有两个遍历的策略：一种是广度优先遍历，一种是深度优先遍历。

先上运行结果吧





图的结构



这里以D顶点为起始顶点





广度优先遍历   

首先我们介绍广度优先遍历，在介绍图的广度优先遍历之前，先回顾一下树的广度优先遍历，就是层序遍历。下面是树的层序遍历代码


void LevelOrder(BitTree t) {
	Linkqueue q;//声明一个链队列
	initQueue(q);//初始化一个链队列

	B...

			
		

	



              


  
              

                


	

		

			

				
					
图的深度优先遍历（用邻接矩阵表示图）

				
			

			

				

					不识不知的博客
				

				

					05-11
					
					2856
					
				

			

		

		

			
				
图的深度优先遍历（用邻接矩阵表示图）#include <stdio.h>
#include <stdlib.h>
void bianli(bool students[8][8],int student[8],int i,bool temp[8])
{
    printf("%d\n",student[i]);
    temp[i]=0;
    for(int j=0;j<8;j++)

			
		

	





	

		

			

				
					
数据结构-图的深度遍历和广度遍历-邻接矩阵-邻接表

				
			

			

				

					weixin_39518639的博客
				

				

					07-02
					
					961
					
				

			

		

		

			
				
structfun.h
//数据结构函数头文件

#include <stdio.h>
#include <iostream>
#include<string>

using std::cout;
using std::cin;
using std::string;

#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define INFINITY 65535//无穷大
typedef string ElemType;
.

			
		

	



		

			
		



	

		

			

				
					
无向图的领接表

				
			

			

				

					qq_32998153的博客
				

				

					07-27
					
					1276
					
				

			

		

		

			
				
无向图的领接表。
#include 
#include 
typedef struct EdgeNode{     // 边表结点 
	int adjvex;              // 领接点域，存储该顶点对应的下标             
	struct EdgeNode *next;   // 链域，指向下一个领接点 
}EdgeNode;

typedef struct Verte

			
		

	





	

		

			

				
					
图深度优先遍历邻接矩阵表示

				
			

			

				

					u012967763的专栏
				

				

					07-24
					
					3082
					
				

			

		

		

			
				
#include 

using namespace std;

const int INF = 9999;
int book[101],sum,n,e[101][101];

void dfs(int cur);

int main()
{
    int i,j,m,a,b;
    cin>>n>>m;
    //初始化二维矩阵
    for(i = 1;i <= n;i++)
    

			
		

	





	

		

			

				
					
邻接矩阵深度优先遍历

				
			

			

				

					
				

				

					12-05
					
					2767
					
				

			

		

		

			
				
因此，在搜索过程中，可以先搜索节点i的所有相邻节点，然后再搜索这些相邻节点的相邻节点。当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这是一个基本的DFS算法，对于邻接矩阵表示的图，可以用来遍历所有的节点。注意，这个算法可能会访问一些不需要的节点，如果需要访问所有连通分量，需要修改算法。避免重复搜索：在搜索过程中，可以记录已经访问过的节点，避免重复访问。初始时，所有节点都标记为未访问。好的，除了避免访问不必要的节点外，还可以采用其他一些优化措施来提高深度优先搜索的性能。

			
		

	





	

		

			

				
					
基于邻接矩阵的图遍历方式(深度优先+广度优先)—C语言

				
			

			

				

					qq_38236355的博客
				

				

					09-25
					
					2万+
					
				

			

		

		

			
				
深度优先遍历： 类似与树的前序遍历。从图中的某个顶点v出发，访问此顶点，然后从v的未被访问到的邻接点进行遍历，直到图中所有和v有路径相通的顶点都被访问到（注：优先访问外层节点，访问到无新顶点时，会进行回退，访问未被访问过的分支顶点）。
广度优先遍历： 类似于树的层序遍历。从图中的某个顶点w出发，让顶点w入队，然后顶点w再出队，并让所有和顶点w相连的顶点入队，然后再出队一个顶点t，并让所有和t相连但...

			
		

	





	

		

			

				
					
基于邻接矩阵的有向图的广度优先遍历(BFS)和深度优先遍历(DFS)算法

				
			

			

				

					Scavenger的博客
				

				

					10-19
					
					7685
					
				

			

		

		

			
				
↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓下面给出有向图的例子↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓下面是求第一个邻接节点和其余邻接节点的实现代码结果如我们所见，这里的1 0 2 4 3分别对应的顶点在顶点表中对应的索引值。

			
		

	





	

		

			

				
					
c语言图的邻接矩阵的遍历（深度和广度遍历）

				
			

			

				

					weixin_51710069的博客
				

				

					06-13
					
					1546
					
				

			

		

		

			
				
有了图 的表示 肯定就有遍历 的操作
下面是对于 图的邻接矩阵的遍历
遍历分为 深度和广度遍历  深度是运用了栈的思想 数据小可以递归  广度是运用了队列来实现
/*构建领接矩阵 无向图*/

#include<iostream>
#include<cstring>
#include<queue> 
using namespace std;

#define Max_int 32767//最大的数 无穷大 
#define Mvnum 100
bool visited[M

			
		

	





	

		

			

				
					
图（领接矩阵和vector）的dfs和bfs

				
			

			

				

					From2016cxg
				

				

					09-24
					
					579
					
				

			

		

		

			
				
//Uva572 图的dfs求连通块
#include
#include
#include
using namespace std;
int m,n;
int dir[8][2] = {{-1,0},{-1,1},{0,1},{1,1},
                 { 1,0},{1,-1},{0,-1},{-1,-1}};
bool vis[105][105];
cha

			
		

	





	

		

			

				
					
邻接矩阵表示的深度优先搜索

				
			

			

				

					cool_oyty的专栏
				

				

					11-19
					
					812
					
				

			

		

		

			
				
#include
#include

#define MAXVEX 100//最大顶点数
typedef struct {
	char vexs[MAXVEX];//顶点表 
	int edges[MAXVEX][MAXVEX];//邻接矩阵
	int n, e;//顶点数和边 
}MGraph;

int visited[100];
void DFSM(MGraph *G,

			
		

	





	

		

			

				
					
无向图--邻接矩阵、连接矩阵、深度遍历、广度遍历、生成树

				
			

			

				

					ChainingBlocks
				

				

					09-15
					
					2367
					
				

			

		

		

			
				
1、开始生成的无向图	2、由图深度优先遍历生成的树  package graph;import java.util.ArrayList;import java.util.Iterator;import java.util.LinkedList;import java.util.List;import java.util.Queue;import java.util.Stack;public cla

			
		

	





	

		

			

				
					
数据结构之图(二)——邻接矩阵

					
热门推荐

				
			

			

				

					daocaoren_的博客
				

				

					08-06
					
					8万+
					
				

			

		

		

			
				
图的逻辑结构为多对多，图没有顺序存储结构，但可以借助二维数组来表示元素间的关系，即数组表示法(邻接矩阵)。图的链式存储结构可以用多重链表来描述，如邻接表，邻接多重表以及十字链表等。
邻接矩阵

数组(邻接矩阵)表示法：
建立一个邻接表(记录各个顶点信息)和一个邻接矩阵(表示各个顶点间的关系)。
1.设图A=(V,E)有n个顶点，则有顶点表Vexs[n]如下，





i
0
1
2
⋯\cdot...

			
		

	





	

		

			

				
					
数据结构学习笔记——图的存储结构（邻接矩阵、邻接表、邻接多重表和十字链表）

				
			

			

				

					小宇y的博客
				

				

					08-14
					
					2万+
					
				

			

		

		

			
				
图的常用存储结构有邻接矩阵和邻接表，另外还有十字链表、邻接多重表等等。//图的顶点数目、图的边数目 char V [ MAXSIZE ];//一维数组，存储顶点 int E [ MAXSIZE ] [ MAXSIZE ];//二维数组，边的邻接矩阵 } Graph;100//图的顶点数目、图的边数目 char V [ MAXSIZE ];//一维数组，存储顶点 int E [ MAXSIZE ] [ MAXSIZE ];//二维数组，边的邻接矩阵 } Graph;.........

			
		

	





	

		

			

				
					
图的邻接矩阵存储法详解与C++实现

				
			

			

				

					m0_68805093的博客
				

				

					07-22
					
					2147
					
				

			

		

		

			
				
邻接矩阵法存储图，以及对图的基本操作的C/C++代码实现

			
		

	





	

		

			

				
					
图的四种存储方式（邻接矩阵、邻接表、十字链表、邻接多重表）

				
			

			

				

					kusunoki的博客
				

				

					08-01
					
					6890
					
				

			

		

		

			
				
介绍了邻接矩阵、邻接表、十字链表以及邻接多重表，并详细记录了用于有向图的十字链表以及用于无向图的邻接多重表的画法。

			
		

	





	

		

			

				
					
图的邻接矩阵

				
			

			

				

					banhu_LongjinG的博客
				

				

					07-11
					
					4475
					
				

			

		

		

			
				
图 邻接矩阵

			
		

	





	

		

			

				
					
领接矩阵存储图的深度优先遍历

					
最新发布

				
			

			

				

					05-08
				

			

		

		

			
				
### 邻接矩阵存储图并进行深度优先遍历

#### 算法描述
深度优先遍历（Depth First Search, DFS）是一种用于遍历或搜索树或图的算法。它从给定的起始节点开始，沿着一条路径尽可能深入地探索，直到无法继续为止，然后回溯到最近的一个未完全访问的节点，重复这一过程。

对于基于邻接矩阵表示的图，可以通过递归的方式实现DFS。以下是具体实现方法：

1. 使用布尔数组 `visited` 来记录每个顶点是否已被访问过。
2. 对于每一个尚未被访问过的顶点，调用递归函数对其进行访问，并标记为已访问。
3. 在递归过程中，依次检查当前顶点与其他顶点之间的连接关系，若存在边且目标顶点未被访问，则对该顶点执行相同的递归操作。

---

#### C++ 实现代码
以下是一个完整的C++程序，展示了如何使用邻接矩阵来存储图以及实现深度优先遍历的功能。

```cpp
#include <iostream>
#include <string>

using namespace std;

#define MAX_VERTICES 100 // 最大顶点数

// 定义无向图的邻接矩阵结构体
struct Graph {
    string vertices[MAX_VERTICES]; // 存储顶点名称
    int edges[MAX_VERTICES][MAX_VERTICES]; // 邻接矩阵
    int vertexCount; // 当前顶点数量
};

// 初始化图
void initializeGraph(Graph &graph) {
    graph.vertexCount = 0;
    for (int i = 0; i < MAX_VERTICES; ++i) {
        for (int j = 0; j < MAX_VERTICES; ++j) {
            graph.edges[i][j] = 0; // 初始时所有边权重设为0
        }
    }
}

// 添加顶点
bool addVertex(Graph &graph, const string &vertexName) {
    if (graph.vertexCount >= MAX_VERTICES) return false; // 超过最大容量则返回失败
    graph.vertices[graph.vertexCount++] = vertexName;
    return true;
}

// 添加边
bool addEdge(Graph &graph, int start, int end) {
    if (start < 0 || start >= graph.vertexCount || end < 0 || end >= graph.vertexCount) return false;
    graph.edges[start][end] = 1; // 设置有边相连
    graph.edges[end][start] = 1; // 如果是有向图可以去掉这一步
    return true;
}

// 深度优先遍历辅助函数（递归）
void dfsHelper(const Graph &graph, bool visited[], int currentVertex) {
    cout << graph.vertices[currentVertex] << " "; // 访问当前顶点
    visited[currentVertex] = true; // 标记为已访问
    
    // 遍历其他顶点
    for (int nextVertex = 0; nextVertex < graph.vertexCount; ++nextVertex) {
        if (!visited[nextVertex] && graph.edges[currentVertex][nextVertex]) {
            dfsHelper(graph, visited, nextVertex); // 继续递归访问相邻顶点
        }
    }
}

// 主函数启动深度优先遍历
void depthFirstSearch(const Graph &graph, int startIndex) {
    bool visited[MAX_VERTICES] = {false}; // 创建一个布尔数组初始化为false
    dfsHelper(graph, visited, startIndex);
}

// 测试主函数
int main() {
    Graph g;
    initializeGraph(g);

    // 添加顶点
    addVertex(g, "A");
    addVertex(g, "B");
    addVertex(g, "C");
    addVertex(g, "D");

    // 添加边
    addEdge(g, 0, 1); // A-B
    addEdge(g, 0, 2); // A-C
    addEdge(g, 1, 3); // B-D

    cout << "深度优先遍历结果：" << endl;
    depthFirstSearch(g, 0); // 从顶点"A"开始遍历
    cout << endl;

    return 0;
}
```

---

#### 关键说明
1. **邻接矩阵构建**  
   邻接矩阵通过二维数组 `edges` 表示图中的边关系。如果两个顶点之间存在边，则对应的矩阵位置值为1；否则为0[^2]。

2. **递归逻辑**  
   在递归过程中，每次都会尝试访问与当前顶点直接相连的所有未访问顶点。这种策略确保了能够按照深度方向逐步扩展遍历范围[^1]。

3. **时间复杂度分析**  
   假设图中有 \( V \) 个顶点和 \( E \) 条边，在最坏情况下，需要检查所有的顶点及其可能的连接情况，因此总的时间复杂度为 \( O(V^2) \)[^1]。

---



			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值