邻接矩阵的深度优先和广度优先搜索

该程序使用C语言实现了图的邻接矩阵表示,并提供了深度优先搜索(DFS)和广度优先搜索(BFS)的算法。DFS遍历顺序为0134256,BFS遍历顺序为0123456。这展示了图遍历的基本操作和理解图数据结构的重要性。
摘要由CSDN通过智能技术生成

c语言中图的邻接矩阵的深度优先和广度优先搜索

#include<stdio.h>
#include<stdlib.h>
typedef struct 
{
	int vexs[7];
	int arcs[7][7];
	int vexnum,arcnum;
}AMGraph;
bool visited[7];
int con[7];
int com=0;
int initlink(AMGraph &p)
{
	int i;
	for(i=0;i<p.vexnum;i++)
		visited[i+1]=false;
	for (i=0;i<7;i++)
	{
		con[i]=NULL;
	}
}
int push(int n)
{
	con[com]=n;
	com+=1;
}
int pop()
{
	int i,j;
	i=con[0];
	if (con[1]==NULL)
	{
		com-=1;
		con[0]=NULL;
		return i;
	}
	for (j=0;j<6;j++)
	{
		if(con[j+1]!=NULL)
		{
			con[j]=con[j+1];
			con[j+1]=NULL;
		}
	}
	com-=1;
	return i;
}
int Init(AMGraph &p)
{
	int i,j;
	p.vexnum=p.arcnum=7;
	p.arcs[0][1]=p.arcs[0][2]=p.arcs[0][3]=p.arcs[0][4]=p.arcs[0][6]=1;
	p.arcs[1][3]=p.arcs[1][6]=1;
	p.arcs[2][4]=1;
	p.arcs[3][4]=p.arcs[3][5]=1;
	p.arcs[4][5]=1;
	p.arcs[5][6]=1;
	p.arcs[0][5]=0;
	for (i=0;i<7;i++)
	{
		p.vexs[i]=i;
		for (j=0;j<7;j++)
			{
				
				if(p.arcs[i][j]==1)
				{
					p.arcs[j][i]=1;
					continue;
				}
				p.arcs[i][j]=0;
			}
	}
	p.arcs[0][5]=p.arcs[5][0]=0;
}
int DFS(AMGraph &p,int n)//深度优先搜索 
{
	int i,j;
	printf("%d ",n);
	visited[n]=true;
	for (i=0;i<7;i++)
	{
		if (p.arcs[n][i]==1)
		{
			if(!visited[i])
				DFS(p,i);
		}
	}
}
int DFSTraverse(AMGraph &p)//深度优先 
{
	int i,j;
	for(i=0;i<p.vexnum;i++)
		visited[i+1]=false;
	for(i=0;i<p.vexnum;i++)
		if(!visited[i])
			DFS(p,i);
}
int BFS(AMGraph &p,int n)
{
	int i,j,v;
	initlink(p);
	printf("%d ",n);
	push(n);
	while(com!=0)
	{
		v=pop();
		for (i=0;i<7;i++)
		{
			if (p.arcs[v][i]==1)
			{
				if(!visited[i])
				{
					printf("%d ",i);
					visited[i]=true;
					push(i);
				}
			}
		}
	}
	return 0;
}
int main()
{//头指针尾指针 
	AMGraph p;
	Init(p);
	DFSTraverse(p);
	printf("\n");
	BFS(p,0);
}

程序输出:

深度优先:0134256

广度优先:0123456

 

 

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
邻接矩阵是一种图的存储结构,它可以用来表示有限个顶点之间的关系。邻接矩阵深度优先遍历和广度优先遍历是图的两种基本遍历方式。 邻接矩阵深度优先遍历(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
发出的红包

打赏作者

万家灯火@

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

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

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

打赏作者

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

抵扣说明:

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

余额充值