DFS-基于邻接表

10 深度优先遍历-邻接表-有向连通图

#include <iostream>
using namespace std;

#define MaxVnum 100   //顶点最大数

bool visited[MaxVnum];//访问标志数组，其初值默认为"false"

typedef char VexType; //顶点的数据类型

typedef struct AdjNode
{
	int v; //存顶点下标
	struct AdjNode * next; //指向下一个邻接点

}AdjNode; //邻接点 结点 结构体

typedef struct
{
	VexType data;   //顶点的数据
	AdjNode * First;//指向第一个邻接点

}VexNode; //顶点结构体

typedef struct
{
	VexNode Vex[MaxVnum]; //顶点集
	int VexNum, EdgeNum;  //顶点数，边数

}ALGraph; //Adjacent List Graph:图的邻接表结构

int LocateVex(ALGraph G, VexType V)
{
	for (int i = 0; i < G.VexNum; i++) //查找顶点信息的下标
	{
		if (V == G.Vex[i].data)
		{
			return i;
		}
	}
	//没找到
	return -1;
}


void InsertEdge(ALGraph & G, VexType LocV1, VexType LocV2)//因为是有向图，需要插入一条边
{
	//构造一个邻接点
	AdjNode * Node = new AdjNode; //C语言中：AdjNode * Node = (AdjNode *)malloc(sizeof(AdjNode));
	
	//放入顶点下标
	Node->v = LocV2;

	//头插法
	Node->next = G.Vex[LocV1].First;
	G.Vex[LocV1].First = Node;
}


void CreateGraph(ALGraph & G)
{
	int i;
	VexType v1, v2;
	cout << "请输入顶点数和边数：" << endl;
	cin >> G.VexNum >> G.EdgeNum;

	//1.顶点结构体初始化
	cout << "请输入顶点的元素：" << endl;
	for (i = 0; i < G.VexNum; i++)
	{
		cin >> G.Vex[i].data;
		G.Vex[i].First = NULL;
	}

	cout << "请依次输入每条边的两个顶点v1,v2" << endl;
	while (G.EdgeNum--)
	{
		cin >> v1 >> v2;
		//2.找这两个顶点的下标
		int Locv1 = LocateVex(G, v1);
		int Locv2 = LocateVex(G, v2);

		if (Locv1 != -1 && Locv2 != -1)
		{
			//3.找到, 进行头插
			InsertEdge(G, Locv1, Locv2);
		}
		else
		{
			cout << "输入顶点信息错！请重新输入！" << endl;
			G.EdgeNum++; //本次输入不算
		}
	}
}

void PrintGraph(ALGraph G)
{
	int i;
	cout << "----------邻接表如下：----------" << endl;
	for (i = 0; i<G.VexNum; i++)
	{
		AdjNode * t = G.Vex[i].First; //保存首指针，防止首指针丢失

		cout << G.Vex[i].data << "的邻接点：" ;
		while (NULL != t)
		{
			cout << "[" << t->v << "]  ";
			t = t->next;
		}
		cout << endl;
	}
}

//深度优先遍历 - 基于邻接表
void DFS_AL(ALGraph G, int Locv)
{
	AdjNode * p;
	int w;
	cout << G.Vex[Locv].data << "\t";
	visited[Locv] = true;

	p = G.Vex[Locv].First;
	while (NULL != p)
	{
		w = p->v;
		if (visited[w] == false)
		{
			DFS_AL(G, w);
		}
		p = p->next;
	}
}

void test01()
{
	ALGraph G;
	VexType v;

	//创建有向图
	CreateGraph(G);
	//输出有向图
	PrintGraph(G);

	//深度优先遍历 - 基于邻接表
	cout << "请输入遍历连通图的起始点：" << endl;
	cin >> v;

	int Locv = LocateVex(G, v);

	if (Locv != -1)
	{
		cout << "深度优先搜索遍历连通图结果：" << endl;
		DFS_AL(G, Locv);
	}
	else
	{
		cout << "输入顶点信息错！请重新输入！" << endl;
	}
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

11 深度优先遍历-邻接表-无向连通图

#include <iostream>
using namespace std;

#define MaxVnum 100   //顶点最大数

bool visited[MaxVnum];//访问标志数组，其初值默认为"false"

typedef char VexType; //顶点的数据类型

typedef struct AdjNode
{
	int v; //存顶点下标
	struct AdjNode * next; //指向下一个邻接点

}AdjNode; //邻接点 结点 结构体

typedef struct
{
	VexType data;   //顶点的数据
	AdjNode * First;//指向第一个邻接点

}VexNode; //顶点结构体

typedef struct
{
	VexNode Vex[MaxVnum]; //顶点集
	int VexNum, EdgeNum;  //顶点数，边数

}ALGraph; //Adjacent List:邻接表

int LocateVex(ALGraph G, VexType V)
{
	for (int i = 0; i < G.VexNum; i++) //查找顶点信息的下标
	{
		if (V == G.Vex[i].data)
		{
			return i;
		}
	}
	//没找到
	return -1;
}


void InsertEdge(ALGraph & G, VexType LocV1, VexType LocV2)
{
	//构造一个邻接点
	AdjNode * Node1 = new AdjNode; //C语言中：AdjNode * Node = (AdjNode *)malloc(sizeof(AdjNode));

	//放入顶点下标
	Node1->v = LocV2;

	//头插法
	Node1->next = G.Vex[LocV1].First;
	G.Vex[LocV1].First = Node1;
}


void CreateGraph(ALGraph & G)
{
	int i;
	VexType v1, v2;
	cout << "请输入顶点数和边数：" << endl;
	cin >> G.VexNum >> G.EdgeNum;

	//1.顶点结构体初始化
	cout << "请输入顶点的元素：" << endl;
	for (i = 0; i < G.VexNum; i++)
	{
		cin >> G.Vex[i].data;
		G.Vex[i].First = NULL;
	}

	cout << "请输入每条边的两个顶点v1,v2" << endl;
	while (G.EdgeNum--)
	{
		cin >> v1 >> v2;
		//2.找这两个顶点的下标
		int Locv1 = LocateVex(G, v1);
		int Locv2 = LocateVex(G, v2);

		if (Locv1 != -1 && Locv2 != -1)
		{
			//3.找到, 进行头插, 因为是无向图，需要插入两条边
			InsertEdge(G, Locv1, Locv2);
			InsertEdge(G, Locv2, Locv1);
		}
		else
		{
			cout << "输入顶点信息错！请重新输入！" << endl;
			G.EdgeNum++; //本次输入不算
		}
	}
}

void PrintGraph(ALGraph G)
{
	int i;
	cout << "----------邻接表如下：----------" << endl;
	for (i = 0; i < G.VexNum; i++)
	{
		AdjNode * t = G.Vex[i].First; //保存首指针，防止首指针丢失

		cout << G.Vex[i].data << "的邻接点： ";
		while (NULL != t)
		{
			cout << "[" << t->v << "]  ";
			t = t->next;
		}
		cout << endl;
	}
}

void DFS_AM(ALGraph G, int Locv)
{
	AdjNode * p;
	int w;
	cout << G.Vex[Locv].data << "\t";
	visited[Locv] = true;

	p = G.Vex[Locv].First;
	while (NULL != p)
	{
		w = p->v;
		if (visited[w] == false)
		{
			DFS_AM(G, w);
		}
		p = p->next;
	}
}

void test01()
{
	ALGraph G;
	VexType v;

	//创建无向图
	CreateGraph(G);
	//输出无向图
	PrintGraph(G);

	//深度优先遍历 - 基于邻接表
	cout << "请输入遍历连通图的起始点：" << endl;
	cin >> v;

	int Locv = LocateVex(G, v);

	if (Locv != -1)
	{
		cout << "深度优先搜索遍历连通图结果：" << endl;
		DFS_AM(G, Locv);
	}
	else
	{
		cout << "输入顶点信息错！请重新输入！" << endl;
	}
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

12 深度优先遍历-邻接表-有向非连通图

#include <iostream>
using namespace std;

#define MaxVnum 100   //顶点最大数

bool visited[MaxVnum];//访问标志数组，其初值默认为"false"

typedef char VexType; //顶点的数据类型

typedef struct AdjNode
{
	int v; //存顶点下标
	struct AdjNode * next; //指向下一个邻接点

}AdjNode; //邻接点 结点 结构体

typedef struct
{
	VexType data;   //顶点的数据
	AdjNode * First;//指向第一个邻接点

}VexNode; //顶点结构体

typedef struct
{
	VexNode Vex[MaxVnum]; //顶点集
	int VexNum, EdgeNum;  //顶点数，边数

}ALGraph; //Adjacent List Graph:图的邻接表结构

int LocateVex(ALGraph G, VexType V)
{
	for (int i = 0; i < G.VexNum; i++) //查找顶点信息的下标
	{
		if (V == G.Vex[i].data)
		{
			return i;
		}
	}
	//没找到
	return -1;
}


void InsertEdge(ALGraph & G, VexType LocV1, VexType LocV2)
{
	//构造一个邻接点
	AdjNode * Node = new AdjNode; //C语言中：AdjNode * Node = (AdjNode *)malloc(sizeof(AdjNode));
	
	//放入顶点下标
	Node->v = LocV2;

	//头插法
	Node->next = G.Vex[LocV1].First;
	G.Vex[LocV1].First = Node;
}


void CreateGraph(ALGraph & G)
{
	int i;
	VexType v1, v2;
	cout << "请输入顶点数和边数：" << endl;
	cin >> G.VexNum >> G.EdgeNum;

	//1.顶点结构体初始化
	cout << "请输入顶点的元素：" << endl;
	for (i = 0; i < G.VexNum; i++)
	{
		cin >> G.Vex[i].data;
		G.Vex[i].First = NULL;
	}

	cout << "请依次输入每条边的两个顶点v1,v2" << endl;
	while (G.EdgeNum--)
	{
		cin >> v1 >> v2;
		//2.找这两个顶点的下标
		int Locv1 = LocateVex(G, v1);
		int Locv2 = LocateVex(G, v2);

		if (Locv1 != -1 && Locv2 != -1)
		{
			//3.找到, 进行头插
			InsertEdge(G, Locv1, Locv2);
		}
		else
		{
			cout << "输入顶点信息错！请重新输入！" << endl;
			G.EdgeNum++; //本次输入不算
		}
	}
}

void PrintGraph(ALGraph G)
{
	int i;
	cout << "----------邻接表如下：----------" << endl;
	for (i = 0; i<G.VexNum; i++)
	{
		AdjNode * t = G.Vex[i].First; //保存首指针，防止首指针丢失

		cout << G.Vex[i].data << "的邻接点：" ;
		while (NULL != t)
		{
			cout << "[" << t->v << "]  ";
			t = t->next;
		}
		cout << endl;
	}
}

//深度优先遍历 - 基于邻接表
void DFS_AL(ALGraph G, int Locv)
{
	AdjNode * p;
	int w;
	cout << G.Vex[Locv].data << "\t";
	visited[Locv] = true;

	p = G.Vex[Locv].First;
	while (NULL != p)
	{
		w = p->v; //w为v的邻接点
		if (visited[w] == false) //w未被访问
		{
			DFS_AL(G, w);
		}
		p = p->next;
	}
}

//函数重载
void DFS_AL(ALGraph G)//非连通图，基于邻接表的深度优先遍历
{
	for (int i = 0; i < G.VexNum; i++)
	{
		if (visited[i] == false)
		{
			DFS_AL(G, i);//i未被访问,以i为起点再次深度优先遍历
		}
	}
}

void test01()
{
	ALGraph G;
	VexType v;

	//创建有向图
	CreateGraph(G);
	//输出有向图
	PrintGraph(G);

	//深度优先遍历 - 基于邻接表
	cout << "请输入遍历连通图的起始点：" << endl;
	cin >> v;

	int Locv = LocateVex(G, v);

	if (Locv != -1)
	{
		cout << "深度优先搜索遍历连通图结果：" << endl;
		DFS_AL(G, Locv);
	}
	else
	{
		cout << "输入顶点信息错！请重新输入！" << endl;
	}

	//非连通图需要查漏点，检查未被访问的顶点
	DFS_AL(G);
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}
posted @   小帅博客  阅读(167)  评论(0)  编辑  收藏  举报
编辑推荐：
· go语言实现终端里的倒计时
· 如何编写易于单元测试的代码
· 10年+ .NET Coder 心语，封装的思维：从隐藏、稳定开始理解其本质意义
· .NET Core 中如何实现缓存的预热？
· 从 HTTP 原因短语缺失研究 HTTP/2 和 HTTP/3 的设计差异
阅读排行：
· 周边上新：园子的第一款马克杯温暖上架
· 分享 3 个 .NET 开源的文件压缩处理库，助力快速实现文件压缩解压功能！
· Ollama——大语言模型本地部署的极速利器
· DeepSeek如何颠覆传统软件测试？测试工程师会被淘汰吗？
· 使用C#创建一个MCP客户端
点击右上角即可分享
微信分享提示
AI IDE Trae