图的遍历DFS和BFS

邻接矩阵的DFS和BFS遍历

邻接矩阵实现图
#define Maxnum 100;
#define Maxnum 100
typedef struct ENode * Edge;
struct ENode
{
	int V1, V2;
	int weight;
};
typedef struct GNode * Graph;
struct GNode
{
	int Nv; // 顶点数
	int Ne; // 边数
	int G[Maxnum][Maxnum];
};
Graph createGraph(int VertexNum) //建立一个无边的图
{
	Graph G = (Graph)malloc(sizeof(struct GNode));
	G->Nv = VertexNum;
	G->Ne = 0;
	for (int i = 0; i < G->Nv; i++)
	{
		for (int j = 0; j < G->Nv; j++)
		{
			G->G[i][j] = 0;
		}
	}
	return G;
}
void insertVertex(Graph G ,Edge E)
{
	G->G[E->V1][E->V2] = E->weight;
}
int main()
{
	int Nv;
	Graph G;
	Edge E;
	scanf_s("%d", &Nv); //输入顶点的个数
	G = createGraph(Nv); //建立图
	scanf_s("%d", &G->Ne); //输入图的边数
	if (G->Ne != 0)
	{
		E = (Edge)malloc(sizeof(struct ENode));
		for (int i = 0; i < G->Ne; i++)
		{
			scanf_s("%d%d%d", &E->V1, &E->V2, &E->weight); // 输入一条边
			insertVertex(G, E); // 插入边
		}
	}
}

DFS的遍历
与树的先序遍历类似

bool visited[Maxnum]; // 用来做标记，值为false表示节点未被访问，true为已被访问
void DFS(Graph G,int Vertex) 
{
	visited[Vertex] = true; // 访问节点
	for(int i = 0; i<G->Nv;i++)
	{
		if(G[Vertex][i]!=0&&visited[i]==false)  
		{
			DFS(G，i);
		}	
	}
}
void ListDFS(Graph G) 
{
	for(int i=0;i<G->Nv;i++)
	{
		if(visited[i] == false)
		{
			DFS(G,i);
		}
	}
}

BFS遍历 ，与层次遍历类似;使用队列实现

bool visited[Maxnum]; // 用来做标记，值为false表示节点未被访问，true为已被访问
void BFS(Graph G, int S)
{
	int V;
	Queue Q; // 队列Q
	Q = creatQueue(Maxnum);// 初始化队列;
	visited[S] = true // 访问节点;
	AddQ(Q,S) // 入队;
	while(IsEmptry(Q))
	{
		V = DelQ(Q);  // 出队列
		for(int i = 0; i<G->Nv;i++)
		{
			if(G[V][i] !=0 &&visited[i] == false)
			{
				visited[i] = true ; //访问
				AddQ(Q,i); //入队
			}
		}
	}
}
void ListBFS(Graph G)
{
	for(int i; i<G->Nv;i++)
	{
		if(visited[i] == false)
		{
			BFS(G,i);
		}
	}
}

邻接表的DFS与BFS的遍历

邻接表实现图
#define Maxnum 100
typedef struct ENode * Edge;
struct ENode
{
	int V1, V2;
	int weight;
};
typedef struct AdjNode* Adj;
struct AdjNode
{
	int Adjv; // 下标
	int weight; // 权重
	Adj next; // 指向下一个;
};
typedef struct VNode
{
	Adj FirstEdge;
}AdjList[Maxnum];

typedef struct GNode * Graph;
struct GNode
{
	int Nv; // 顶点数
	int Ne; // 边数
	AdjList G;
};
Graph CreateGraph(int VertexNum) //建立有VertexNum个顶点的图
{
	Graph G = (Graph)malloc(sizeof(struct GNode));
	G->Nv = VertexNum;
	G->Ne = 0;

	for (int i = 0; i < G->Nv; i++)
	{
		G->G[i].FirstEdge = NULL;
	}
	return G;
}
void InsertEdge(Graph G, Edge E)
{
	Adj NewNode = (Adj)malloc(sizeof(struct AdjNode));
	NewNode->weight = E->weight;
	NewNode->Adjv = E->V2;
	NewNode->next = G->G[E->V1].FirstEdge;
	G->G[E->V1].FirstEdge = NewNode;
	//若为无向图  将 V1 插入 V2
	NewNode = (Adj)malloc(sizeof(struct AdjNode));
	NewNode->Adjv = E->V1;
	NewNode->weight = E->weight;
	NewNode->next = G->G[E->V2].FirstEdge;
	G->G[E->V2].FirstEdge = NewNode;
}
void main()
{
	Graph G;
	Edge E;
	int Nv;
	scanf_s("%d", &Nv);
	G = CreateGraph(Nv);
	scanf_s("%d", &G->Ne);
	if (G->Ne != 0)
	{
		E = (Edge)malloc(sizeof(struct ENode));
		for (int i = 0; i < G->Ne; i++)
		{
			scanf_s("%d%d%d", &E->V1, &E->V2, &E->weight);
			InsertEdge(G, E);
		}
	}
}

DFS的遍历

bool visited[Maxnum]; // 用来做标记，值为false表示节点未被访问，true为已被访问
void ListDFS(Graph G)
{
	for(int i = 0; i<G->Nv;i++)
	{
		if(visited[i])
		{
			DFS(G,i);
		}
	}
}
void DFS(Graph G , int Vertex)
{
	Adj W;
	visited[Vertex] = true;
	for(W = G->G[Vertex].FirstEdge ; W ; W=W->next)
	{
		if(!visited[W->Adjv])
		{
			DFS(G,W->Adjv);
		}
	}
｝

BFS的遍历

void BFS(Graph G,int i)
{
	linkQueue Q;
	Adj W;
	int V;
	Q = createQueue();
	AddQ(Q, i);
	visited[i] = true;
	printf("%d  ", i);
	while (!Emptry(Q))
	{
		V = DelQ(Q);
		for (W = G->G[V].FirstEdge; W ; W = W->next)
		{					
			if (!visited[W->Adjv])
			{
				visited[W->Adjv] = true;
				printf("%d  ", W->Adjv);
				AddQ(Q, W->Adjv);
			}
		}
	}
}
void ListBFS(Graph G)
{
	for (int i = 0; i < G->Nv; i++)
	{
		if (!visited[i])
		{
			BFS(G, i);
		}
	}
}