图的DFS和BFS遍历算法（采用邻接矩阵的存储结构创建无向图G）

#include<iostream>
using namespace std;
#define MaxInt 0  
#define MVNum  8		//顶点的个数 
typedef char  VerTexType;   //顶点的数据类型
typedef int   ArcType;	 	//边的权值的数据类型
typedef struct
{
	VerTexType vexs[MVNum]; 	  //顶点表
	ArcType arcs[MVNum][MVNum];   //邻接矩阵
	int vexnum,arcnum;			  //图的点数和边数 
}AMGraph;
typedef struct QNode
{
	char  data;
	struct QNode *next;
}QNode,*QueuePtr;
typedef struct 
{
	QueuePtr front;   //队头指针 
	QueuePtr rear;    //队尾指针 
}LinkQueue;
void InitQueue (LinkQueue &Q) //构造一个空队列Q 
{
  	Q.front=Q.rear= new QNode;    //生成新节点作为头结点，队头和队尾指针指向此结点
	Q.front->next=NULL;           //头结点的指针域置空  
}

void EnQueue(LinkQueue &Q,char e)  //链队的入队 
{
	QNode *p;
	p=new QNode;
	p->data=e;
	p->next=NULL;
	Q.rear->next=p;
    Q.rear=p;       
}

char DeQueue(LinkQueue &Q)   //链队的出队 
{
	QNode *p;
	char e;
	p=new QNode;
	if(Q.front==Q.rear)  
	{
		Q.front=NULL;
	}
	else
    {
	   p=Q.front->next;
	   e=p->data; 
	   Q.front->next = p->next;
	   if(p==Q.rear) Q.rear = Q.front;
	   delete p; 
	   return e;
	}
}
int  LocateVex(AMGraph &G,char v)  //查找v在顶点表中的位置 
{
	for(int i=0;i<G.vexnum; i++)
	{
		if(v==G.vexs[i])
		{
			return i;
		}
	}
}
void  CreateUDN(AMGraph &G)
{//采用邻接矩阵创建
    int i,j,n;
	VerTexType v1,v2;
	ArcType w; 
    cout<<"请依次输入图的顶点数和边数"<<endl;	
	cin>>G.vexnum>>G.arcnum;
	cout<<"请依次输入顶点的信息"<<endl;
	for (i = 0; i<G.vexnum; i++) 	//输入点的信息 
	{
		cin>>G.vexs[i];
	}
	for (i = 0; i<G.vexnum; i++)	//初始化邻接矩阵 
	{
		
		for (j = 0; j<G.vexnum; j++)
		{
			G.arcs[i][j]=MaxInt;
		}
	}
	for (n = 0; n<G.arcnum; ++n)
	{
		cout<<"请输入边的两端顶点以及权值"<<endl; 
		cin>>v1>>v2>>w; 		//输入一条边两端的顶点及权值 
		i=LocateVex(G,v1);		//查找V1在G中的位置，即顶点数组的下标 
		j=LocateVex(G,v2);
		G.arcs[i][j]=w;
		G.arcs[j][i]=G.arcs[i][j]; //置<v1,v2>的对称边<v2,v1>的权值为w 
	} 
}
void OutGraph(AMGraph &G)   //输出邻接矩阵 
{
	int n=0;
	int i,j;
	for (i = 0; i<G.vexnum; i++)	
	{
		for (j = 0;j<G.vexnum; j++)
		{  
			cout<<" "<<G.arcs[i][j];
			n++;
			if(n%G.vexnum==0)
			{
				cout<<endl;
			}
		}
	}
}
void DFS_AM(AMGraph G,int v,int visited[])   //使用邻接矩阵表示图的DFS遍历 
{

  cout<<G.vexs[v];
  visited[v]=1;	
  for(int w=0;w<G.vexnum;w++)
  {
  	if((G.arcs[v][w]!=0)&&(!visited[w])) 
  	{
	      DFS_AM(G,w,visited);  
	} 
  }
}

int FistAdjVex(AMGraph G,char u)  //BFS遍历中起始遍历顶点的第一个邻接点 
{
	  int v1,w;
	  v1=LocateVex(G,u); 
	for(w=0;w<G.vexnum;w++)
   {
  	if(G.arcs[v1][w]==1) 
  	{ 
	      return w; 
	} 
   }
   if(w>=G.vexnum)
   {
      return -1;
   }
}
int NextAdjVex(AMGraph G,char u,int w) //BFS遍历中起始遍历顶点相对于 遍历过的其他顶点的 下一个顶点 
{
	int v2,i;
	v2=LocateVex(G,u); 
	for(i=w+1;i<G.vexnum;i++)
	{
		if(G.arcs[v2][i]==1)
		{
		   	return i;
		}
	}
	if(w>=G.vexnum)
	{
		return -1;
	}
}
void BFS(AMGraph G,char v,int visited1[])  //BFS遍历 
{
	LinkQueue Q;
	InitQueue(Q);
	VerTexType u;
	int w;
	int v1; 
	cout<<v;
	v1=LocateVex(G,v);
	visited1[v1]=1;
    EnQueue(Q,v);
    while(Q.front!=NULL)
	{
		u=DeQueue(Q);
		for(w=FistAdjVex(G,u);w>=0;w=NextAdjVex(G,u,w))
		{
			if(!visited1[w])
			{
				cout<<G.vexs[w];
				visited1[w]=1;
				EnQueue(Q,G.vexs[w]);
			}
		}
	}	
}
main()
{
	AMGraph G;
	VerTexType vex;
	int v;
	int visited[8];
	int visited1[8]; 
	CreateUDN(G);
	for(int i=0;i<G.vexnum;i++)  //初值为0 
  {
  	   visited[i]=0;
  }
  	for(int i=0;i<G.vexnum;i++)  //初值为0 
  {
  	   visited1[i]=0;
  }
    OutGraph(G); 
	cout<<"请输入开始遍历的起始顶点:";
	cin>>vex;
	v=LocateVex(G,vex);
	cout<<"DFS遍历结果为："<<endl; 
    DFS_AM(G,v,visited); 
    cout<<endl; 
    cout<<"BFS遍历结果为："<<endl; 
    BFS(G,vex,visited1);
}