图的遍历

/*
程序说明：本程序模拟演示了图的邻接表存储，以及图的深度和广度优先遍历
这里我选择用链表来存储边，用队列来存储顶点，其实可以调用C++的相关容器，例如：list,deque，vector等。
我之所以自己写一遍是为了复习之前所学。

注意：我的顶点是从0开始，但是实际顶点个数从1开始计数，即没有第0个顶点，如果你从1开始输入，
那么就会造成数组下标越界，导致栈溢出。如果要测试复杂的连通图，可以适当将MAX_VERTEX_NUM调大。
*/

#include <iostream>
#include <cstdlib>
using namespace std;

#define MAX_VERTEX_NUM 5  //顶点的个数

typedef struct ArcNode
{
	//单链表中结点的类型
	int adjvex;  //该边指向的顶点在顺序表中的位置（数组下标）
	struct ArcNode *next;  //下一条边
}ArcNode;

typedef struct VNode
{
	//顶点类型
	int data;  //顶点中的数据信息
	ArcNode *firstarc;  //指向单链表，即指向第一条边
}VNode;

typedef struct QNode
{
	int data;  //链队列结点中的数据域
	struct QNode *next;  //链队列结点中的指针域
}QNode,*QueuePtr;

typedef struct
{
	QueuePtr front;  //队头指针
	QueuePtr rear;  //队尾指针
}LinkQueue;

int visited[MAX_VERTEX_NUM]={0,0,0,0,0};  //定义访问标志数组

//重载输入输出，即>>和<<
istream &operator>>(istream &in,VNode &G)
{
	in>>G.data;
	return in;
}

ostream &operator<<(ostream &out,const VNode &G)
{
	out<<G.data;
	return out;
}

//创建图
void CreateGraph(int n,VNode G[])
{
	int i,e;
	ArcNode *p,*q=NULL;
	cout<<"请输入顶点的信息："<<endl;
	for(i=0;i<n;i++)
	{
		cin>>G[i];
		G[i].firstarc=NULL;  //初始化第一条边为空
	}
	for(i=0;i<n;i++)
	{
		cout<<"创建第"<<i+1<<"个顶点的边（输入-1结束）："<<endl;
		cin>>e;
		while(e!=-1)
		{
			ArcNode *p=new ArcNode();  //创建一条边
			p->next=NULL;
			p->adjvex=e;
			if(G[i].firstarc==NULL)
			{
				G[i].firstarc=p;  //i结点的第一条边
			}
			else
			{
				q->next=p;  //下一条边
			}
			q=p;
			cin>>e;
		}
	}
}

//返回第一邻接点在数组中的下标
int FirstAdj(Vnode G[],int v)
{
	if(G[v].firstarc!=NULL)
	{
		return (G[v].firstarc)->adjvex;
	}
	return -1;
}

//返回下一个邻接点在数组中的下标
int NextAdj(VNode G[],int v,int w)
{
	ArcNode *p;
	p=G[v].firstarc;
	while(p!=NULL)
	{
		if(p->adjvex==w && p->next!=NULL)
		{
			return p->next->adjvex;
		}
		p=p->next;
	}
	return -1;
}

//深度优先搜索一个连通图
void DFS(VNode G[],int v)
{
	int w;
	cout<<G[v]<<" ";  //访问当前顶点并打印信息
	visited[v]=1;  //将顶点v对应的访问标记置1
	w=FirstAdj(G,v);  //找到顶点v的一个邻接点，否则返回-1
	while(w!=-1)
	{
		if(visited[w]==0)  //该顶点未被访问
		{
			DFS(G,w);  //递归的进行深度优先遍历
		}
		w=NextAdj(G,v,w);  //找到顶点v的下一个邻接点，否则返回-1
	}
}

//对图G=(V,E)进行深度优先搜索的主算法
void Travel_DFS(VNode G[],int n)
{
	int i;
	for(i=0;i<n;i++)
	{
		visited[i]=0;  //将标记数组初始化为0
	}
	for(i=0;i<n;i++)
	{
		//若有顶点未被访问，则从该顶点开始继续深度优先遍历
		if(visited[i]==0)
		{
			DFS(G,i);
		}
	}
}

//初始化一个空队列
void initQueue(LinkQueue *q)
{
	//创建一个头结点，队头指针和队尾指针指向该节点
	q->front=q->rear=new QNode();
	
	//创建头结点失败
	if(!q->front)
	{
		return;
	}
	q->front->next=NULL;  //头结点指针域置空
}

void EnQueue(LinkQueue *q,int e)
{
	//创建一个队列元素结点
	QueuePtr p=new QNode();
	//创建元素结点失败
	if(p==NULL)
	{
		return;
	}
	p->data=e;  //将数据e存放到队列结点的数据域中
	p->next=NULL;  //指针域置空
	q->rear->next=p;  //从队尾插入节点
	q->rear=p;  //修改队尾指针
}

//如果队列q不为空，删除q的队头元素，用e返回其值
void DeQueue(LinkQueue *q,int e)
{
	QueuePtr p;
	//队列为空，返回
	if(q->front==q->rear)
	{
		return;
	}
	p=q->front->next;  //p指向队列的第一个元素
	*e=p->data;  //将队首元素的数据赋值给e返回
	q->front->next=p->next;  //删除头结点
	
	//如果此时队列为空，则修改队尾指针
	if(q->rear==p)
	{
		q->rear=q->front;
	}
	delete p;
}

//判断队列是否为空
int emptyQ(LinkQueue *q)
{
	if(q->rear==q->front)
	{
		return 1;
	}
	return 0;
}

//广度优先搜索一个连通图
void BFS(VNode G[],int v)
{
	int w;
	LinkQueue q;
	initQueue(&q);
	cout<<G[v]<<" ";  //访问顶点v
	visited[v]=1;  //将顶点v的访问标记置1
	EnQueue(&q,v);  //顶点v入队列
	while(!emptyQ(&q))
	{
		DeQueue(&q,&v);  //出队列，元素由v返回
		w=FirstAdj(G,v);  //找到顶点v的第一个邻接点，否则返回-1
		while(w!=-1)
		{
			if(visited[w]==0)
			{
				cout<<G[w]<<" ";
				EnQueue(&q,w);  //顶点w入队列
				visited[w]=1;
			}
			w=NextAdj(G,v,w);  //找到顶点v的下一个邻接点，否则返回-1
		}
	}
}

void Travel_BFS(VNode G[],int n)
{
	int i;
	for(i=0;i<n;i++)
	{
		visited[i]=0;  //初始化标记数组
	}
	for(i=0;i<n;i++)
	{
		//若有顶点未被访问，则从该顶点开始继续广度优先遍历
		if(visited[i]==0)
		{
			BFS(G,i);
		}
	}
}

//重置访问标记数组
void resetVisitedTrace()
{
	int i;
	for(i=0;i<MAX_VERTEX_NUM;i++)
	{
		visited[i]=0;
	}
}

int main()
{
	VNode G[MAX_VERTEX_NUM];  //图中顶点的存储容器
	CreatGraph(MAX_VERTEX_NUM,G);
	cout<<"深度优先遍历结果："<<endl;
	Travel_DFS(G,MAX_VERTEX_NUM);
	resetVisitedTrace();
	cout<<endl;

	cout<<"广度优先遍历结果："<<endl;
	Travel_BFS(G,MAX_VERTEX_NUM);
	cout<<endl;

	system("pause");
	return 0;
}

测试结果展示

邻接表存储