数据结构-图的进阶代码

1.BFS算法求解单源最短路径（BFS总是按照距离由近到远来遍历）

#define MAX_VERTEX_NUM 1024
#define INFINITY 0
bool visited[MAX_VERTEX_NUM];
Sequeue Q;
int d[MAX_VERTEX_NUM];
void BFS_MIN_Distance(Graph G,int u){//d[i]表示u到i节点最短路径
	for(int i=0;i<G.vexnum;++i)
		d[i]=INFINITY;
	InitQueue(Q);
	visited[u]=TRUE;
	EnQueue(Q,u);
	while(!isEmpty(Q)){
		DeQueue(Q,u);
		for(w=FirstNeighbor(G,u);w>=0;w=NextNeighbor(G,u,w))
			if(!visited[w]){
				visited[w]=TRUE;
				d[w]=d[u]+1;
				EnQueue(Q,w);
			}
	}
}

2.判断图是否是一棵树（是否是连通图）

#define MAX_VERTEX_NUM 1024
bool visited[MAX_VERTEX_NUM];
bool IsTree(Graph G){
	if(G.vexnum!=G.arcnum-1)	//不满足树的性质直接false
		return FALSE;
	for(int i=0;i<G.vexnum;i++)
		visited[i]=FALSE;
	DFS(G,0);
	for(int i=0;i<G.vexnum;i++)
		if(visited[i]==FALSE)
			return FALSE;		//进行一次DFS有一个孤立点就false
	return TRUE;
}      
void DFS(Graph G,int v){
	visited[v]=TRUE;
	for(int w=FirstNeighbor(G,v);w>=0;w=NextNeighor(G,v,w))	//图为邻接矩阵存储
		if(!visited[w])
			DFS(G,w);
}

3.设图邻接表存储，设计一个算法，输出顶点Vi到顶点Vj所有简单路径

#define MAX_VERTEX_NUM 1024
#define INFINITE -65535
bool visited[MAX_VERTEX_NUM];
int path[MAX_VERTEX_NUM];
void PrintAllSimplenessPath(ALGraph G,int From,int To){
	for(int i=0;i<G.vexnum;i++)
		visited[i]=FALSE;
	FindPath(G,From,To,0);
}
void FindPath(ALGraph G,int From,int To,int len){
	if(visited[From])
		return;
	path[len]= From;
	visited[u]=TRUE;
	if(From==To){
		for(int i=0;i<len;i++)
			printf(“%d\t”path[i]);
		visited[From]=FALSE;
		return;
	}
	for(AcrNode *w=G.vertices[From];w;w->next)
		FindPath(G,w->next,To,len+1);
	visited[From]=FALSE;
}

4.DFS非递归算法（图用邻接表存储）

#define MAX_VERTEX_NUM 1024
bool visited[MAX_VERTEX_NUM];
void DFS(ALGraph G){
	for(int i=0;i<G.vexnum;i++)
		visited[i]=FALSE;
	SeqStack S;
	for(int i=0;i<G.vexnum;i++){
		if(!visited[i]){
			Push(S,i);
			while(!IsEmpty(S)){
				int v=Pop(S);
				if(!visited[v]){
					visited[v]=TRUE;
					printf(“%d ”,v);
					for(ArcNode *w=G.vertices[v];w;w=w->next)
						if(!visited[w->adjvex])
							Push(S,w->adjvex);
				}
			}
		}
	}
}

5.设无向图G采用邻接表结构存储，试编写算法计算G中包含的连通分量的数量。

bool visited[MaxVertexNum];
int CountSubGraphs(ALGraph G){
	for(int i=0;i<G->n;i++)
		visisted[i]=false;
	int count=0;
	for(int i=0;i<G->n;i++){
		if(!visited[i]){
			DFS(G,i);
			count++;
		}
	}
	return count;
}
void DFS(ALGraph G,int v){
	visited[v]=true;
	ArcNode *p=G=>adjList[v].first;
	while(p){
		if(!visited[p->data])
				DFS(G,p->data);
			p=p->next;	
	}
}

6.在有向图中，我们将入度和出度相等的顶点定义为“平衡顶点”。编写一个算法输出一个采用邻接表存储结构的有向图中所有的平衡顶点。

int InDegree[MaxVertexNum];
int OutDegree[MaxVertexNum];
void BalanceNodes(ALGraph G){
	for(int i=0;i<G->vexnum;i++)
		InDegree[i]=OutDegree[i]=0;
	ArcNode *p;
	for(int i=0;i<G->vexnum;i++){
		p=G->AdjList[i]->first;
		while(p){
			OutDegree[i]++;
			InDegree[p->data]++;
			p=p->next;
		}
		for(int i=0;i<G->vexnum;i++)
			if(InDegree[i]==OutDegree[i])
				cout<<i<<”\t”;
	}
} 

7.假设图采用邻接表存储，试设计算法判断顶点i和顶点j（i不等于j）之间是否有路径。

#define MaxVertexNum 100
bool visited[MaxVertexNum];
bool DFSTrave(ALGraph G，int From,int To){
	for(int i=0;i<G->vexnum;i++)	visited[i]=0;
	DFS(G,From);
	if(visited[To])
		return true;
	return flase;
}
void DFS(ALGraph G,int v){
	visited[v]=true;
	ArcNode *p=G=>adjList[v].first;
	while(p){
		if(!visited[p->data])
			DFS(G,p->data);
		p=p->next;	
	}
}

8.假设一个连通图采用邻接表作为存储结构，设计一个算法，判断其中是否存在回路。

bool JudeCycle(ALGraph G){
	bool has=false;
	if(G->vexnum==2){//两个顶点的连通图单独来判断
		if(G->arcnum==1) has=true;	
	}	
	else	Cycle(G,1,has)		//假如顶点是从1开始
	return has;
}
void Cycle(ALGraph G,int v,bool &has){	//调用has时置初值为false
	ArcNode *p;
	int w;
	visited[v]=true;
	p=G->AdjList[v].first;
	while(p){
		w=p->adjvex;
		if(!visited[w])
			Cycle(G,w,has);
		else{
			has=true;
			return;
		}
		p=p->next;
	}
}