基于邻接矩阵和邻接表的两种方法实现无向图的BFS和DFS

        广度优先搜索(Breadth-First-Search)和深度优先搜索(Deep－First－Search)是搜索策略中最经常用到的两种方法,特别常用于图的搜索.

BFS的思想：
      从一个图的某一个顶点V0出发，首先访问和V0相邻的且未被访问过的顶点V1、V2、……Vn，然后依次访问与V1、V2……Vn相邻且未被访问的顶点。如此继续，找到所要找的顶点或者遍历完整个图。我们采用队列来存储访问过的节点。

DFS的思想：

      深度优先搜索所遵循的策略就是尽可能“深”的在图中进行搜索，对于图中某一个顶点V，如果它还有相邻的顶点且未被访问，则访问此顶点。如果找不到，则返回到上一个顶点。这一过程一直进行直到所有的顶点都被访问为止。 DFS可以搜索出从某一个顶点到另外的一个顶点的所有路径。 由于要进行返回的操作，我们采用的是递归的方法。

邻接表：

      邻接表是图的一种链式存储结构。在邻接表中，对图中的每个顶点vi建立一个单链表，把鱼vi相邻的顶点放在这个链表中。

邻接矩阵：

     邻接矩阵是表示顶点之间相邻关系的矩阵。设G(V,E）是具有n个顶点的无向图，则其对应了一个n阶方阵。设这个方阵为A，则对于A[i][j]有两种取值，当A[i][j]=1时，表示顶点i和顶点j是连通的；当A[i][j]=0时，表示顶点i和顶点j是不连通的。

基于邻接矩阵的DFS:

<span style="font-size:14px;">//基于邻接矩阵的DFS，时间复杂度为O(n^2)
#include <stdio.h>
#include <string.h>
const int GNumber = 8;//存储节点个数
int G[GNumber][GNumber];//存储邻接矩阵
int color[GNumber];//存储节点状态

void DFS_Visit(int G[][GNumber], int i, int n){
	int j;
	color[i] = 1;
	for(j=0; j< n; j++){
		if(G[i][j] && !color[j]){
			printf(" V%d ", j+1);
			color[j] = 1;
			DFS_Visit(G, j, n);
		}
	}
}

void DFS(int G[][GNumber], int n){
	int i;
	memset(color, 0, sizeof(color));
	for(i=0; i<n; i++){//遍历每一个节点
		if(!color[i]){//判断是否访问
			printf(" V%d ", i+1);
			DFS_Visit(G,i,n);
			printf("\n");
		}
	}
}

int main(){
	FILE *fr;
	int i,j;
	fr = fopen("测试用例.txt","r");
	if(!fr){
		printf("fopen failed\n");
		return -1;
	}
	while(fscanf(fr,"%d%d", &i, &j) != EOF){
		G[i-1][j-1] = 1;
		G[j-1][i-1] = 1;
	}
	DFS(G,GNumber);
	getchar();
	return 0;
}</span>

基于邻接矩阵的BFS:

<span style="font-size:14px;">//基于邻接矩阵的BFS，时间复杂度为O(n^2)
#include <stdio.h>
#include <string.h>

const int GNumber = 8;//存储节点个数
int G[GNumber][GNumber];//存储邻接矩阵
int color[GNumber];// 防止回环,记录节点状态 

struct Queue{//用数组模拟队列 
	int queue[GNumber];
	int start;
	int end;
}MyQueue;

void BFS(int G[][GNumber], int n){
	int j;
	MyQueue.queue[MyQueue.end++] = 0;
	color[0] = 1;
	while(MyQueue.end != MyQueue.start){
		for(j=0; j<n; j++){
			if(G[MyQueue.start][j] && !color[j]){
				color[j] = 1;
				MyQueue.queue[MyQueue.end++] = j;
			}
		}
		printf(" V%d ", MyQueue.queue[MyQueue.start++]+1);
	}
}

int main(int argc, char **argv){
	FILE *fr;
	int i,j;
	fr = fopen("测试用例.txt","r");
	if(!fr){
		printf("fopen failed\n");
		return -1; 
	}
	//printf("%d %d\n",MyQueue.start,MyQueue.end);
	while(fscanf(fr,"%d%d", &i, &j) != EOF){
		G[i-1][j-1] = 1;
		G[j-1][i-1] = 1;
	}
	memset(&MyQueue, 0, sizeof(MyQueue));
	memset(color, 0, sizeof(color));
	BFS(G,GNumber);
	getchar();
	return 0;
}</span>

基于邻接表的BFS和DFS：

<span style="font-size:14px;">#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX  8   //最大顶点数

typedef struct node{ //边节点
        int adjvex;  //该边指向的顶点位置
        //int weight
        struct node* next;  //指向下一条边的指针
}ArcNode;//边表结点

typedef struct VNode{
        int vertex;
        ArcNode* firstarc; //指向第一条依附该顶点的指针
}VNode;//顶点表结点

typedef VNode Adjlist[MAX+1];//adj_list是邻接表类型

typedef struct {
        int n, m;//图中顶点数和边数
        Adjlist adjlist;//邻接表
}ALGraph;

void create_algraph(ALGraph* g)//建立无向图的邻接表
{
	ArcNode* newnode;
    int i, j, k;
	printf("please input node number and edge number: ");
	scanf("%d%d", &g->n, &g->m);
	printf("node number = %d, edges = %d\n", g->n, g->m);
	for(i = 1; i <= g->n; i++){
		g->adjlist[i].vertex = i;
		g->adjlist[i].firstarc = NULL;
	}
	printf("please input new edge: \n");//用相邻的两个顶点来表示边
	for(k = 1; k <= g->m; k++){
		scanf("%d%d", &i, &j);
		//printf("\n");
		newnode = (ArcNode* )malloc(sizeof(ArcNode));
		newnode->adjvex = j;
		//newnode->weight = 0;
		newnode->next = g->adjlist[i].firstarc;
		g->adjlist[i].firstarc = newnode;
		newnode = (ArcNode* )malloc(sizeof(ArcNode));
		newnode->adjvex = i;
		//newnode->weight = 0;
		newnode->next = g->adjlist[j].firstarc;
		g->adjlist[j].firstarc = newnode;
	}
}

void pr_algraph(ALGraph* g)//输出邻接表
{
	ArcNode* node;
	int i;
	for(i = 1; i<= g->n; i++){
		node = g->adjlist[i].firstarc;
		printf("g->adjlist[%d] = %d: ", i, g->adjlist[i].vertex);
		while(node != NULL){
				printf("%d \t", node->adjvex);
				node = node->next;
		}
		printf("\n");
	}
}

int visted[MAX+1];//记录节点状态
void DFS(ALGraph *g,int v)
{
	visted[v] = 1;			//访问初始点
	ArcNode *p = g->adjlist[v].firstarc;
	while(p!=NULL)
	{
		if (visted[p->adjvex]==0){	//如果没有被访问过，则递归调用DFS访问
			printf("%d ",p->adjvex);
			DFS(g,p->adjvex);
		}
		p = p->next;//继续下一条边
	}
	//printf("\n");
}

void BFS(ALGraph *g,int v)
{
	//for (int i=0;i<g->n;i++) visted[i] = 0;
	int queue[MAX],front,rear;
	front = rear = 0;
	rear = (rear+1)%MAX;
	queue[rear] = v; //v顶点入队
	int u;
	ArcNode *p;
	while(/*rear!=0*/front!=rear)//当队列满时
	{
		front = (front+1)%MAX;
		u = queue[front];
		p = g->adjlist[u].firstarc;
		while(p!=NULL)	//首先访问u的所有节点
		{
			if (visted[p->adjvex]==0)
			{
				visted[p->adjvex] = 1;	//访问p->adjvex节点，标记为访问
				rear = (rear+1)%MAX;	
				printf("%d ",p->adjvex);
				queue[rear] = p->adjvex;	//p->adjvex节点入队
			}
			p = p->next;
		}
	}
	printf("\n");
}

int main(int argc, char** argv)
{
	ALGraph* g;//定义一个无向图

	g = (ALGraph* )malloc(sizeof(ALGraph));
	printf("begin create algraph\n");
	create_algraph(g);
	printf("finish create algraph\n");

	printf("the algraph is:\n");
	pr_algraph(g);
	memset(visted,0,sizeof(visted));
	visted[1]=1;
	printf("BFS is:\n");
	printf("1 ");
	BFS(g,1);
	memset(visted,0,sizeof(visted));
	printf("DFS is:\n");
	printf("1 ");
	DFS(g,1);
	printf("\n");
	return 0;
}

</span>

          邻接矩阵和邻接表都是实现BFS和DFS的方法，邻接矩阵时间复杂度为O(n^2)，邻接表的时间复杂度为O(n+e);因此邻接矩阵适用于稠密图，邻接表适用于稀疏图。