7-6 列出连通集 go语言/C语言

最新推荐文章于 2023-11-15 20:05:12 发布

馋馋猫

最新推荐文章于 2023-11-15 20:05:12 发布

阅读量319

点赞数

文章标签：算法数据结构

本文链接：https://blog.csdn.net/ccccm__/article/details/106315967

版权

给定一个有N个顶点和E条边的无向图，请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1编号。进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。

输入格式:
输入第1行给出2个整数N(0<N≤10)和E，分别是图的顶点数和边数。随后E行，每行给出一条边的两个端点。每行中的数字之间用1空格分隔。

输出格式:
按照"{ v1 v2 ... vk }"的格式，每行输出一个连通集。先输出DFS的结果，再输出BFS的结果。

输入样例:

输出样例:

{ 0 1 4 2 7 }
{ 3 5 }
{ 6 }
{ 0 1 2 7 4 }
{ 3 5 }
{ 6 }

go语言不熟练,争取多练练!

go代码:

package main

import (
	"fmt"
)

var visited [10]bool

//N 是边
var N int

//E 是顶点
var E int

//Graph 是图形结构
type Graph struct {
	arcs [10][10]int //临界矩阵
}

func main() {

	fmt.Scanln(&N, &E)
	G := BuildGraph()
	ListDFS(G)
	for i := 0; i < N; i++ {
		visited[i] = false
	}
	ListBFS(G)
}

//BuildGraph 创建图
func BuildGraph() Graph {
	var n1, n2 int
	G := new(Graph)

	for i := 0; i < E; i++ {

		fmt.Scanln(&n1, &n2)
		// fmt.Println("n1=",n1," n2=",n2)
		G.arcs[n1][n2] = 1
		G.arcs[n2][n1] = 1
	}
	return *G
}

//ListDFS 外部的DFS函数
func ListDFS(G Graph) {
	for i := 0; i < N; i++ {
		if visited[i] == false {
			fmt.Printf("{")
			DFS(G, i)
			fmt.Printf(" }\n")
		}
	}
}

//ListBFS 外部的BFS函数
func ListBFS(G Graph) {
	// fmt.Println("BFS")
	for i := 0; i < N; i++ {
		if visited[i] == false {
			fmt.Printf("{")
			BFS(G, i)
			fmt.Printf(" }\n")
		}
	}
}

//DFS 内部DFS实现
func DFS(G Graph, v int) {
	visited[v] = true
	fmt.Printf(" %d", v)
	for i := 0; i < N; i++ {
		if visited[i] == false && G.arcs[v][i] == 1 {
			DFS(G, i)
		}
	}
}

//BFS 内部的BFS实现
func BFS(G Graph, v int) {
	var que [18]int
	rear := 0
	front := 0
	visited[v] = true
	que[rear] = v
	rear++
	for rear > front {
		x := que[front]
		fmt.Printf(" %d", x)
		front++
		for i := 0; i < N; i++ {
			if visited[i] == false && G.arcs[x][i] == 1 {
				que[rear] = i
				rear++
				visited[i] = true
			}
		}

	}

}

C代码(这份是初学的时候写的,很杂乱):

#include<stdio.h>
#include<stdlib.h>
#define MaxVertexNum 10

typedef int WeightType;//权重  
typedef int Vertex;//顶点


typedef struct GNode *PtrToGNode;//定义point to  GNode的指针 PtrToGNode
/* 定义邻接矩阵  */
struct GNode{
	int Nv; /* 顶点数 */
	int Ne; /* 边数 */
	WeightType G[MaxVertexNum][MaxVertexNum];
	int visit[MaxVertexNum];
};
typedef PtrToGNode MGraph;	

/* 定义连接线 */ 
typedef struct ENode *PtrToENode;
struct ENode{
	Vertex V1,V2; /* 有向边<V1,V2> */
};
typedef PtrToENode Edge; 

/* 定义队列结构 */
typedef struct queue *PtrToQueue;
struct queue{
	int Front;//列队头 
	int Last;// 列队尾 
	int Que[MaxVertexNum];//定义队列数组	 
}; 
typedef PtrToQueue Queue;



/* 注意这里用Dev写错了内容和返回值没事,pta会不给过 */ 
//建立邻接矩阵的函数
MGraph CreateGraph(int VertexNum);//初始化图 
void InsertEdge(MGraph Graph,Edge E); //插入连接线 
MGraph BuildGraph();
//深度优先搜索方法
void DFS(MGraph M,Vertex v);//一次深度优先搜索
void listDFS(MGraph M);//列出所有的深度优先搜索结果
//清空一次搜索结果
void Reset(MGraph M);
//广度优先搜索需要先定义使用队列的基本操作
Queue CreateQueue();//创建队列
void InQueue(Queue q,Vertex v);//入队
int IsEmpty(Queue q);//判断列队是否为空
Vertex OutQueue(Queue q);//出队
//广度优先搜索方法
void BFS(MGraph M,Vertex v);//广度优先搜索
void ListBFS(MGraph M);//列出所有的广度优先搜索结果


//函数的定义 
MGraph CreateGraph(int VertexNum)
{
	MGraph Graph;//先定义一个指向图的指针 
	Vertex V,W;//V和W其实是表示一个顶点，并不是单纯的整数 ，虽然表示出来是一回事 
	int i; 
	Graph = (MGraph)malloc(sizeof(struct GNode));//申请图的内存空间 然后初始化 
	Graph->Nv = VertexNum;
	Graph->Ne = 0;
	
	for( V = 0; V < VertexNum; V++){//遍历图中的结点,令图中的结点都为0或无穷大,意为没有任何连接 
	//注意上面这里是VertexNum而不是MaxVertexNum,减少多余操作 
		for( W = 0; W < VertexNum; W++){
			Graph->G[V][W] = 0;/* 或者INFINITY */ 
		}
	} 
	for( i = 0; i < VertexNum; i++) Graph->visit[i] = 0;
	return Graph; 
} 

void InsertEdge(MGraph Graph,Edge E)
{
	/* 插入边<V1,V2> */
	Graph->G[E->V1][E->V2] = 1; /* 有权重的话要等于E->Weight*/
	
	/* 若是无向图则要反向也插入 */
	Graph->G[E->V2][E->V1] = 1; /* 有权重的话要等于E->Weight*/
} 

MGraph BuildGraph()
{
	MGraph Graph;
	Vertex V;
	Edge E;
	int Nv,i;
	
	scanf("%d",&Nv);//先输入顶点数 
	Graph = CreateGraph(Nv);
	scanf("%d",&(Graph->Ne));//输入边数 
	if(Graph->Ne != 0){
		E = (Edge)malloc(sizeof(struct ENode));//给连接线申请空间,然后用指针的形式传递给下面的函数 
		for(i=0;i<Graph->Ne;i++){
			scanf("%d%d",&E->V1,&E->V2);
			InsertEdge(Graph,E);//插入,传两个指针效率怪高 
		}
		
	}
	return Graph;//别完了返回 
}

void DFS(MGraph M,Vertex v)
{
	M->visit[v] = 1;//标记访问过
	printf("%d ", v);//打印访问过的元素
	int i;
	for(i=0;i<M->Nv;i++){//这里Nv写成了Ne,这种失误一失足成千古恨 
		if(M->visit[i] == 0 && M->G[v][i] == 1){
			DFS(M,i);//当这个数i没有被访问过并且,这个数是有相邻点的就递归 ,典型的DFS,深度 
		}
	} 
}

void ListDFS(MGraph M)//用两个函数比较方便和调试 
{
	int i;
	for(i=0;i<M->Nv;i++){
		if(M->visit[i] == 0){
			printf("{ ");
			DFS(M,i);
			printf("}\n");
		}
	}
}

void Reset(MGraph M)//其实这里放在main里也行,visit用完要还原 
{
	int i;
	for(i=0;i<M->Nv;i++) M->visit[i] = 0; //我这里Nv写成Ne找了一个小时,哭了都 
}

Queue CreateQueue()//队列的函数,不会去补习(反正我是补习了好久) 
{
	Queue q;
	q = (Queue)malloc(sizeof(struct queue));
	q->Front = q->Last = 0;
	int i;
	for (i = 0; i < MaxVertexNum; i++)
		q->Que[i] = -1;
	return q;
}

void InQueue(Queue q,Vertex v){
	if(q->Last == MaxVertexNum -1) return;
	q->Que[q->Last++] = v;
//	q->Que[q->Last] = v;
//	q->Front++;
	return;
}

int OutQueue(Queue q)
{
	if(IsEmpty(q) == 1	) return -1;
	Vertex v = q->Que[q->Front++];
//	Vertex v = q->Que[q->Front];
//	q->Front++;
	return v;
}

int IsEmpty(Queue q)
{
	if(q->Front == q->Last )
		return 1;
	else 
		return 0;
}

void BFS(MGraph M,Vertex v)//广度的精髓就是队列,原理是入队一个就把这列检查一遍有就扔进队里 
{
	int i; 
	Queue q;
	Vertex temp;
	q = CreateQueue();//创建队列 
	InQueue(q,v);//入队 
	M->visit[v] = 1;//入队完visit要更新 
	while(IsEmpty(q) == 0)
	{
		temp = OutQueue(q);//出队要返还数,检查这个数 
		printf("%d ",temp);//出队一个输出一个 
		for(i=0;i<M->Nv;i++){//Nv和Ne不要写反咯 
			if(M->visit[i] == 0 && M->G[temp][i] == 1){// M->G[i][temp]是无向图所以顺序是可以反着来的 
				InQueue(q,i);
				M->visit[i] = 1;// 入队完visit要更新 !! 
			}
		}
	}
}

void ListBFS(MGraph M)//遍历没有被访问的组就访问一下 
{
	int i;
	for(i=0;i<M->Nv;i++){
		if(M->visit[i] == 0){
			printf("{ ");
			BFS(M,i);
			printf("}\n");
		}
	}
}

int main()//简简单单基础题?
{
	MGraph G;
	G = BuildGraph();
	ListDFS(G);
	Reset(G);
	ListBFS(G);
	return 0;
}