邻接矩阵实现无向图的BFS和DFS

一：DFS

创建邻接矩阵图的结构体

typedef  struct  graph
{
    int vexnum,arcnum;//节点个数，弧的个数
    int tyust[MAX][MAX];//使用二维数组定义一个矩阵
    char vexs[MAX];//存储节点数据
}*Graph;

创建邻接矩阵图

Graph creat_graph()
{
	int vex,arc,p1,p2;
	char in1,in2;
	Graph  pit;
	printf("请输入无向图节点数：\n");
	scanf("%d",&vex);
	printf("请输入无向图弧数：\n");
	scanf("%d",&arc);
	pit=(Graph)malloc(sizeof(graph));
	memset(pit,0,sizeof(graph));

	pit->vexnum=vex;
	pit->arcnum=arc;//初始化

	printf("输入vexs:\n");
	cin>>pit->vexs;//输入节点信息

	//cout<<"测试"<<pit->vexs[7];
	//弧初始化
	for(int j=0;j<arc;j++)
	{
		printf("输入arc(%d)两个顶点：\n",j);
		cin>>in1>>in2;
		//cout<<"in1,in2"<<in1<<in2;//Debug
		p1=get_pos(pit,in1);
		p2=get_pos(pit,in2);
		if(p1==-1||p2==-1)
		{
			cout<<"获取位置失败！！"<<endl;
		}
		pit->tyust[p1][p2]=pit->tyust[p2][p1]=1;
	}	
	print(pit,pit->tyust);
	return pit;
}

返回顶点V第一个连接点的序号，若不存在，返回-1

int FirstAdj(Graph map,int v)
{
	if(v>map->vexnum-1)return -1;
	for(int i=0;i<map->vexnum;i++)
	{
		if(map->tyust[v][i]==1)return i;
	}
	return -1;
}

返回顶点V(相对于W,也就是大于W+1)第一个连接点的序号，若不存在，返回-1

int NextAdj(Graph map,int v,int w)
{
	if(v>map->vexnum-1)return -1;
	for(int i=w+1;i<map->vexnum;i++)
	{
		if(map->tyust[v][i]==1)return i;
	}
	return -1;
}

深度优先遍历使用递归，内层函数DFS:

void DFS(Graph map,int i,int *visit)
{
    int w;
    visit[i]=1;//标志
    for(w=FirstAdj(map,i);w>=0;w=NextAdj(map,i,w))//接着查询这一行其他有链接的边即1
    {
        if(visit[w]==0)
        {
            DFS(map,w,visit);//使用递归一直查找下一个，若是死胡同则返回上一层
        }
    }
}

DFS_travel();个人觉的不需要，注释掉后，程序也可以正常打印出结果

void  DFS_travel(Graph map)
{
	int visit[MAX];
	memset(visit,0,sizeof(visit));//初始化0
	cout<<"深度优先无向图遍历DFS:"<<endl;
/*	for(int i=0;i<map->vexnum;i++)
	{
		if(!visit[i])//未遍历
		{
			DFS(map,i,visit);
		}
	}*/
	DFS(map,0,visit);
}

二：BFS

void  BFS(Graph map)//广度优先遍历
{
	int head=0,rear=0;
	int quene[MAX];
	int visit[MAX];
	int j,k;
	memset(visit,0,sizeof(visit));
	for(int i=0;i<map->vexnum;i++)
	{
		if(!visit[i])
		{
			visit[i]=1;
			cout<<map->vexs[i]<<" ";
			quene[rear++]=i;//把下标入队
		}
		while(head!=rear)
		{
			j=quene[head++];
			for(k=FirstAdj(map,j);k>=0;k=NextAdj(map,j,k))
//遍历某节点的一行数据，即为广度遍历，k返回-1，表示一行遍历完成
//在while(head!=rear)里面，先入队的一次出队，寻找下一行与出队节点有连接的，并再次进队
			{
				if(!visit[k])
				{
					visit[k]=1;
					cout<<map->vexs[k]<<" ";
					quene[rear++]=k;
				}
			}

		}
	}


}

执行函数：

int main()
{

	Graph  map=creat_graph();
	
	DFS_travel(map);
	cout<<"BFS:"<<endl;
	BFS(map);
	return 0;	
}