BFS

#include <stdio.h>
#include<stdlib.h>
#define MaxVertexNum 10   /* 最大顶点数设为10 */
typedef int Vertex;       /* 用顶点下标表示顶点,为整型 */

/* 邻接点的定义 */
typedef struct AdjVNode *PtrToAdjVNode; 
struct AdjVNode{
    Vertex AdjV;        /* 邻接点下标 */
    PtrToAdjVNode Next; /* 指向下一个邻接点的指针 */
};

/* 顶点表头结点的定义 */
typedef struct Vnode{
    PtrToAdjVNode FirstEdge; /* 边表头指针 */
} AdjList[MaxVertexNum];     /* AdjList是邻接表类型 */

/* 图结点的定义 */
typedef struct GNode *PtrToGNode;
struct GNode{  
    int Nv;     /* 顶点数 */
    int Ne;     /* 边数   */
    AdjList G;  /* 邻接表 */
};
typedef PtrToGNode LGraph; /* 以邻接表方式存储的图类型 */
typedef struct queue{
	Vertex data[MaxVertexNum];
	int front,rear;
}*queue;

queue que;
int Visited[MaxVertexNum]; /* 顶点的访问标记 */

LGraph CreateGraph(); /* 创建图并且将Visited初始化 */

void Visit( Vertex V )
{
    printf(" %d", V);
}

void BFS ( LGraph Graph, Vertex S);
queue GreateQueue();
void EnQueue(queue q,Vertex x);
int DeQueue(queue q);
int Empty(queue q);
int FirstNei(LGraph gg,int v);
int NextNei(LGraph gg,int v,int x);

int main()
{
    LGraph G;
    Vertex S;

    G = CreateGraph();
	printf("输入遍历始节点\n");
    scanf("%d", &S);
    printf("BFS from %d:", S);
    BFS(G, S);
	system("pause");
    return 0;
}
LGraph CreateGraph(){
	int i,vi,vj;
	LGraph gg;
	PtrToAdjVNode p,q;
	for(i=0;i<MaxVertexNum;i++)//初始化visit数组
		Visited[i]=0;
	gg=(LGraph)malloc(sizeof(struct GNode));
	printf("输入节点个数,边数\n");
	scanf("%d %d",&gg->Nv,&gg->Ne);
	for(i=0;i<gg->Nv;i++){//头结点置空
		gg->G[i].FirstEdge=NULL;
	}
	printf("向图中加入边\n");
	for(i=0;i<gg->Ne;i++){
		scanf("%d %d",&vi,&vj);
		p=(PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
		p->AdjV=vj;
		p->Next=gg->G[vi].FirstEdge;
		gg->G[vi].FirstEdge=p;

		q=(PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
		q->AdjV=vi;
		q->Next=gg->G[vj].FirstEdge;
		gg->G[vj].FirstEdge=q;
	}

	return gg;
}
/* 你的代码将被嵌在这里 */
void BFS ( LGraph Graph, Vertex S){
	int k,w;
	que=GreateQueue();
	Visit(S);
	Visited[S]=1;
	EnQueue(que,S);
	while(!Empty(que)){
		k=DeQueue(que);
		for(w=FirstNei(Graph,k);w>=0;w=NextNei(Graph,k,w))
			if(!Visited[w]){
				Visited[w]=1;
				Visit(w);
				EnQueue(que,w);
			}
	}
}

queue GreateQueue(){
	queue q;
	q=(queue)malloc(sizeof(struct queue));
	q->front=q->rear=0;
	return q;
}
void EnQueue(queue q,Vertex x){
	q->data[q->rear]=x;
	q->rear=(q->rear+1)%MaxVertexNum;
}
int DeQueue(queue q){
	int temp;
	temp=q->data[q->front];
	q->front=(q->front+1)%MaxVertexNum;
	return temp;
}
int Empty(queue q){
	if(q->front==q->rear)
		return 1;
	else
		return 0;
}
//查找v节点指向的第一个节点
int FirstNei(LGraph gg,int v){
	if(v==-1)
		return -1;
	else if(gg->G[v].FirstEdge==NULL)
		return -1;
	else
		return gg->G[v].FirstEdge->AdjV;

}
//查找v节点指向的x节点的下一个指向到节点
int NextNei(LGraph gg,int v,int x){
	PtrToAdjVNode p;
	if(v==-1)
		return -1;
	p=gg->G[v].FirstEdge;
	while(p && p->AdjV!=x)
		p=p->Next;
	if(p->Next)
		return p->Next->AdjV;
	else
		return -1;
}

DFS

#include<stdio.h>
#include<stdlib.h>
#define N 100
typedef struct adjvex{
	int data;//存储边的权值
	int adjvex;//存储边指向尾节点编号
	struct adjvex * nextAdj;//指向下一条边
}adjvex;
typedef struct vex{
	int vex;//存储邻接表表头节点值
	adjvex* firstAdj;//指向该头结点首条边指向到值
}vex[N];
typedef struct graph{
	vex v;
	int vexNum,adjNum;//存储节点数,边数
}*Graph;

Graph CreatGraph(Graph gg);
void dfsSearch(Graph gg);
void DFS(Graph gg,int v);
int FirstNei(Graph gg,int v);
int NextNei(Graph gg,int v,int x);

Graph G;
int visit[N];
void main(){
	G=CreatGraph(G);
	dfsSearch(G);
	system("pause");
}
//创建图
Graph CreatGraph(Graph gg){
	adjvex * p,*q;
	int i,vi,vj,k;
	gg=(Graph)malloc(sizeof(struct graph));
	printf("输入节点个数,及边的条数\n");
	scanf("%d %d",&gg->vexNum,&gg->adjNum);
	for(i=0;i<gg->vexNum;i++){
		gg->v[i].vex=i;
		gg->v[i].firstAdj=NULL;
	}

	for(i=0;i<gg->adjNum;i++){
		scanf("%d %d %d",&vi,&vj,&k);
		//使用头插法
		p=(adjvex*)malloc(sizeof(struct adjvex));
		p->data=k;
		p->adjvex=vj;
		p->nextAdj=gg->v[vi].firstAdj;
		gg->v[vi].firstAdj=p;
		//头插法插入,无向图对称节点
		q=(adjvex*)malloc(sizeof(struct adjvex));
		q->data=k;
		q->adjvex=vi;
		q->nextAdj=gg->v[vj].firstAdj;
		gg->v[vj].firstAdj=q;

	}

	return gg;
}
//DFS遍历图
void dfsSearch(Graph gg){
	int i;
	for(i=0;i<gg->vexNum;i++)
		visit[i]=0;
	for(i=0;i<gg->vexNum;i++)
		if(!visit[i])
			DFS(gg,i);

}
void DFS(Graph gg,int v){
	int w;
	printf("%d ",v);
	visit[v]=1;
	for(w=FirstNei(gg,v);w>=0;w=NextNei(gg,v,w)){
		if(!visit[w])
			DFS(gg,w);
	}
}
//查找v节点指向的第一个节点
int FirstNei(Graph gg,int v){
	if(v==-1)
		return -1;
	else if(gg->v[v].firstAdj==NULL)
		return -1;
	else
		return gg->v[v].firstAdj->adjvex;

}
//查找v节点指向的x节点的下一个指向到节点
int NextNei(Graph gg,int v,int x){
	adjvex *p;
	if(v==-1)
		return -1;
	p=gg->v[v].firstAdj;
	while(p && p->adjvex!=x)
		p=p->nextAdj;
	if(p->nextAdj)
		return p->nextAdj->adjvex;
	else
		return -1;
}

标签：gg,遍历,return,struct,int,Graph,DFS,BFS,adjvex
来源： https://blog.csdn.net/qq_43271509/article/details/123595031