邻接矩阵的深度遍历和广度遍历

邻接矩阵的深度遍历和广度遍历

图的定义

#ifndef G_H
#include<iostream>
using namespace std;
#define OK 1
#define ERROR -1
#define MaxInt 32767
#define MVNum 100
typedef int Status;
typedef char VerTexType;
typedef int ArcType;
typedef struct
{
	VerTexType vexs[MVNum];
	ArcType arcs[MVNum][MVNum];
	int vexnum,arcnum;
}AMGraph;
Status CreateUDN(AMGraph &G);	
void DFS_AM(AMGraph G,int v);
void BFS(AMGraph G,int v);

函数的定义

#include"G.h"
Status CreateUDN(AMGraph &G)
{
	int i,j,k,w;
	cout<<"节点数:"; 
	cin>>G.vexnum;
	cout<<"总边数:" ;
	cin>>G.arcnum;
	for(i=1;i<=G.vexnum;i++)
		for(j=1;j<=G.vexnum;j++)
			G.arcs[i][j]=0;
	cout<<"输入节点信息:";
	for(i=0;i<G.vexnum;i++)
	{
		cin>>G.vexs[i];
	}
	for(k=1;k<=G.arcnum;++k)
	{
		VerTexType v1,v2;
		cout<<"输入依附的顶点和权值:"; 
		cin>>v1>>v2>>w;
		cout<<endl;
		int p_x,p_y;
		for(int q=0;q<G.vexnum;q++)
		{
			if(G.vexs[q]==v1)
			p_x=q+1;
		}
		for(int q1=0;q1<G.vexnum;q1++)
		{
			if(G.vexs[q1]==v2)
			p_y=q1+1;
		}

		G.arcs[p_x][p_y]=w;
		G.arcs[p_y][p_x]=G.arcs[p_x][p_y];
	}
	return OK;
	
}
int visited[MVNum];
void DFS_AM(AMGraph G,int v)
{
	int w;
	cout<<v<<"    ";
	visited[v]=1;
	for(w=1;w<=G.vexnum;w++)
		if((G.arcs[v][w]!=0)&&(visited[w]!=1)) DFS_AM(G,w);
}
int visited1[MVNum];
void BFS(AMGraph G,int v)
{
	cout<<"\n"<<v<<"    ";
    visited1[v]=1;
    int q[100],front=1,rear=1;
    q[rear++]=v;
    while(front!=rear)
    {
        int now=q[front++];
        for(int i=1;i<=G.vexnum;i++)
        {
            if(G.arcs[now][i]&&!visited1[i])
            {
                visited1[i]=1;
                cout<<"  "<<i<<"\t";
                q[rear++]=i;
            }
        }
    }
}
主函数
#include"G.h"
int main()
{int i, j;
	AMGraph G;
	CreateUDN(G);
	for(i=1;i<=G.vexnum;i++)
	{
		for(j=1;j<=G.vexnum;j++)
		{
			cout<<G.arcs[i][j]<<"\t";	
		}
		cout<<endl;
	}	
			
	int v;
	cout<<"访问的顶点:";
	cin>>v;
	cout<<"深度遍历:"; 
	DFS_AM(G,v);
	cout<<"广度遍历:"; 
	BFS(G,v);
	return OK;
}
邻接矩阵是一种图的存储结构,它可以用来表示有限个顶点之间的关系。邻接矩阵深度优先遍历广度优先遍历是图的两种基本遍历方式。 邻接矩阵深度优先遍历(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、付费专栏及课程。

余额充值