图的基本算法（DFS，BFS, topoSort，SCC）

最新推荐文章于 2024-09-28 23:00:16 发布
最新推荐文章于 2024-09-28 23:00:16 发布 · 536 阅读 · 0
文章标签：

#算法 #图基本算法 #DFS BFS #SCC #TopoSort

本文介绍了一个使用Java实现的图算法框架，包括图的基本表示、构建、广度优先搜索、深度优先搜索、拓扑排序及强连通分支计算等功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

由于要面试的缘故，在看算法导论的图算法一节，决定把基本的算法都用java代码实现出来。
1. 图的表示，使用链接表的形式。
class TreeNode{
	int nodeNum ; //节点编号
	TreeNode parent = null; //遍历时的父节点
	int dis = Integer.MAX_VALUE;// 距离源节点的路径
	int discoverTime =0; //在DFS遍历时发现的时间
	int finishTime =0;//DFS遍历时结束的时间
	Color color = Color.White;//初始时的颜色标记
	List<Integer> edges = new ArrayList<Integer>();//节点的边集合
	
	public TreeNode(int i) {
		nodeNum = i;
	}
	public int getNodeNum() {
		return nodeNum;
	}
	public void setNodeNum(int nodeNum) {
		this.nodeNum = nodeNum;
	}
	public TreeNode getParent() {
		return parent;
	}
	public void setParent(TreeNode parent) {
		this.parent = parent;
	}
	public int getDis() {
		return dis;
	}
	public void setDis(int dis) {
		this.dis = dis;
	}
	public int getDiscoverTime() {
		return discoverTime;
	}
	public void setDiscoverTime(int discoverTime) {
		this.discoverTime = discoverTime;
	}
	public int getFinishTime() {
		return finishTime;
	}
	public void setFinishTime(int finishTime) {
		this.finishTime = finishTime;
	}
}
 
2. 图的构建：
TreeNode[] heads = null;
final int NODENUM ;
public GraphicModelII(int nodeNum) {
   NODENUM = nodeNum;
   heads = new TreeNode[NODENUM+1];
   
   for(int i=1;i<=nodeNum;i++){
   heads[i] = new TreeNode(i);
   }
   }
public void addEdge(int src,int des){
   heads[src].edges.add(des);
   }
 
3. 广度优先搜索
    
public void BFS(int src){
   Queue<TreeNode> searchs = new LinkedList<TreeNode>();	    
   heads[src].color = Color.Gray;
   heads[src].dis= 0;
   searchs.add(heads[src]);
   while(!searchs.isEmpty()){
   TreeNode cur = searchs.poll();
   System.out.println("Node : "+cur.nodeNum);
   for(Integer des:cur.edges){
   TreeNode now  = heads[des];
   if(now.color == Color.White){
   now.color = Color.Gray;
   now.dis = cur.dis+1;
   now.parent = cur;
   searchs.add(now);
   }
   }
   cur.color = Color.Black;
   }
   
   }
 
 
4. 深度优先搜索
 public void DFS(){
   systemTime = 0;
   for(int i=1;i <=NODENUM;i++){
   TreeNode node = heads[i];
   if(node.color==Color.White){
   DFS_Visit(node);
   }
   }
   }
   public void DFS_Visit(TreeNode node){
   node.color = Color.Gray;
   systemTime++;
   node.discoverTime = systemTime; 
   for(Integer des:node.edges){
   TreeNode now = heads[des];
   if(now.color==Color.White){
   now.parent = node;
   DFS_Visit(now);
   }
   }
   node.color = Color.Black;
   systemTime++;
   node.finishTime = systemTime;
   topoSortUtil.push(node);
   System.out.println(node.nodeNum+"start:\t"+node.discoverTime+" end:\t"+node.finishTime);
   }
  
 
 
5. topo 排序：
topo 排序的算法
使用DFS来完成，对于每一个发现的节点，压入栈中
Stack<TreeNode> topoSortUtil = new Stack<TreeNode>();
对应DFS中 黄色标记代码
 public void topoSort(){
   topoSortUtil.clear();
   DFS();
   while(!topoSortUtil.isEmpty()){
   System.out.println(topoSortUtil.pop().nodeNum);
   }
   }
 
6. 求强连通分支SCC。
第一步 使用DFS算法，把每个节点遍历完成时写入到topoSortUtil 中，栈顶的元素是最后才遍历结束的节点。
第二步，求原图G的转置， 把原图中 u -v的边 变为 v-u.
见reverTopo 函数，遍历之后的图用heads_reverse 表示
第三步  使用DFS算法，求SCC。需要注意的是，在原始的DFS中
public void DFS(){
   systemTime = 0;
   for(int i=1;i <=NODENUM;i++){
 
   TreeNode node = heads[i];
   if(node.color==Color.White){
   DFS_Visit(node);
   }
   }
   }
for 循环 的节点顺序无要求，但是在求SCC时，需要使用topoSortUtil，最晚结束遍历的元素作为第二次遍历的第一个元素，并依此类推。
   
 public void SCC(){
  
   DFS();
   List<TreeNode> scc = new ArrayList<TreeNode>();
   reverTopo();
   while(!topoSortUtil.isEmpty()){
  TreeNode cur = heads_reverse[topoSortUtil.pop().nodeNum];
  if(cur.color==Color.White){
  DFS_Visit_Scc(cur,scc);
   }
  for(TreeNode node:scc){
  System.out.print(node.nodeNum);
  }
  System.out.println();
  scc.clear();
   }
   }
   
   public void DFS_Visit_Scc(TreeNode node,List<TreeNode> scc){
   node.color = Color.Gray;
   systemTime++;
   node.discoverTime = systemTime; 
   for(Integer des:node.edges){
   TreeNode now = heads_reverse[des];
   if(now.color==Color.White){
   now.parent = node;
   DFS_Visit_Scc(now,scc);
   }
   }
   node.color = Color.Black;
   systemTime++;
   node.finishTime = systemTime;
   scc.add(node);
   }
   
   private void reverTopo(){
   for(int i=1;i <=NODENUM;i++){
   TreeNode node = heads[i];
   int src = node.nodeNum;
   for(Integer des:node.edges){
   TreeNode reverNode = heads_reverse[des];
   reverNode.edges.add(src);
   }
   }
   }
 
完整代码
package graphic;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;

public class GraphicModelII {
	TreeNode[] heads = null;
	final int NODENUM ;
	static int  systemTime = 0;
	Stack<TreeNode> topoSortUtil = new Stack<TreeNode>();
	TreeNode[] heads_reverse = null;
	
	
	public GraphicModelII(int nodeNum) {
		   NODENUM = nodeNum;
		   heads = new TreeNode[NODENUM+1];
		   heads_reverse =new TreeNode[NODENUM+1];
		   
		   for(int i=1;i<=nodeNum;i++){
			   heads[i] = new TreeNode(i);
			   heads_reverse[i] = new TreeNode(i);
		   }
	   }
	   public void addEdge(int src,int des){
		   heads[src].edges.add(des);
	   }
	   
	   
	   public void BFS(int src){
		   Queue<TreeNode> searchs = new LinkedList<TreeNode>();
		   
		   heads[src].color = Color.Gray;
		   heads[src].dis= 0;
		   searchs.add(heads[src]);
		   while(!searchs.isEmpty()){
			   TreeNode cur = searchs.poll();
			   System.out.println("Node : "+cur.nodeNum);
			   for(Integer des:cur.edges){
				   TreeNode now  = heads[des];
				   if(now.color == Color.White){
					   now.color = Color.Gray;
					   now.dis = cur.dis+1;
					   now.parent = cur;
					   searchs.add(now);
				   }
			   }
			   cur.color = Color.Black;
		   }
		   
	   }
	   
	   public void DFS(){
		   systemTime = 0;
		   for(int i=1;i <=NODENUM;i++){
			
			   TreeNode node = heads[i];
			   if(node.color==Color.White){
				   DFS_Visit(node);
			   }
		   }
	   }
	   public void DFS_Visit(TreeNode node){
		   node.color = Color.Gray;
		   systemTime++;
		   node.discoverTime = systemTime; 
		   for(Integer des:node.edges){
			   TreeNode now = heads[des];
			   if(now.color==Color.White){
				   now.parent = node;
				   DFS_Visit(now);
			   }
		   }
		   node.color = Color.Black;
		   systemTime++;
		   node.finishTime = systemTime;
		   topoSortUtil.push(node);
		   System.out.println(node.nodeNum+"start:\t"+node.discoverTime+" end:\t"+node.finishTime);
	   }
	   
	   public void topoSort(){
		   topoSortUtil.clear();
		   DFS();
		   while(!topoSortUtil.isEmpty()){
			   System.out.println(topoSortUtil.pop().nodeNum);
		   }
	   }
	   
	   public void SCC(){
		  
		   DFS();
		   List<TreeNode> scc = new ArrayList<TreeNode>();
		   reverTopo();
		   while(!topoSortUtil.isEmpty()){
			  TreeNode cur = heads_reverse[topoSortUtil.pop().nodeNum];
			  if(cur.color==Color.White){
				  DFS_Visit_Scc(cur,scc);
			   }
			  for(TreeNode node:scc){
				  System.out.print(node.nodeNum);
			  }
			  System.out.println();
			  scc.clear();
		   }
	   }
	   
	   public void DFS_Visit_Scc(TreeNode node,List<TreeNode> scc){
		   node.color = Color.Gray;
		   systemTime++;
		   node.discoverTime = systemTime; 
		   for(Integer des:node.edges){
			   TreeNode now = heads_reverse[des];
			   if(now.color==Color.White){
				   now.parent = node;
				   DFS_Visit_Scc(now,scc);
			   }
		   }
		   node.color = Color.Black;
		   systemTime++;
		   node.finishTime = systemTime;
		   scc.add(node);
	   }
	   
	   private void reverTopo(){
		   for(int i=1;i <=NODENUM;i++){
			   TreeNode node = heads[i];
			   int src = node.nodeNum;
			   for(Integer des:node.edges){
				   TreeNode reverNode = heads_reverse[des];
				   reverNode.edges.add(src);
			   }
		   }
	   }
	   
	   public static void main(String[] args) {
//		   GraphicModelII graph = new GraphicModelII(5);
//		   graph.addEdge(1, 2);
//		   graph.addEdge(1, 5);
//		   graph.addEdge(2, 1);
//		   graph.addEdge(2, 5);
//		   graph.addEdge(2, 4);
//		   graph.addEdge(2, 3);
//		   graph.addEdge(3, 2);
//		   graph.addEdge(3, 4);
//		   graph.addEdge(4, 2);
//		   graph.addEdge(4, 5);
//		   graph.addEdge(5, 4);
//		   graph.addEdge(5, 2);
//		   graph.addEdge(5, 1);
		  // graph.BFS(1);
		   //graph.DFS();
//		   GraphicModelII graph = new GraphicModelII(9);
//		   graph.addEdge(1, 2);
//		   graph.addEdge(1, 8);
//		   graph.addEdge(2, 3);
//		   graph.addEdge(2, 8);
//		   graph.addEdge(3, 6);
//		   graph.addEdge(4, 3);
//		   graph.addEdge(4, 5);
//		   graph.addEdge(5, 6);
//		   graph.addEdge(7, 8);
//		   graph.topoSort();
		   
		   //test scc
		   GraphicModelII graph = new GraphicModelII(8);
		   graph.addEdge(1, 2);
		   graph.addEdge(2, 3);
		   graph.addEdge(3, 4);
		   graph.addEdge(4, 3);
		   graph.addEdge(2, 5);
		   graph.addEdge(2, 6);
		   graph.addEdge(3, 7);
		   graph.addEdge(4, 8);
		   graph.addEdge(5, 1);
		   graph.addEdge(5, 6);
		   graph.addEdge(6, 7);
		   graph.addEdge(7, 6);
		   graph.addEdge(7,8);
		   graph.addEdge(8,8);
		   //graph.topoSort();
		   graph.SCC();
	   }
}
class TreeNode{
	int nodeNum ;
	TreeNode parent = null;
	int dis = Integer.MAX_VALUE;
	int discoverTime =0;
	int finishTime =0;
	Color color = Color.White;
	List<Integer> edges = new ArrayList<Integer>();
	
	public TreeNode(int i) {
		nodeNum = i;
	}
	public int getNodeNum() {
		return nodeNum;
	}
	public void setNodeNum(int nodeNum) {
		this.nodeNum = nodeNum;
	}
	public TreeNode getParent() {
		return parent;
	}
	public void setParent(TreeNode parent) {
		this.parent = parent;
	}
	public int getDis() {
		return dis;
	}
	public void setDis(int dis) {
		this.dis = dis;
	}
	public int getDiscoverTime() {
		return discoverTime;
	}
	public void setDiscoverTime(int discoverTime) {
		this.discoverTime = discoverTime;
	}
	public int getFinishTime() {
		return finishTime;
	}
	public void setFinishTime(int finishTime) {
		this.finishTime = finishTime;
	}
	
	
}
 
图的DFS（算法分析）
Shao_yihao的博客
04-17 1291
DFS的基本思想就是：只要可能，就在图中尽量“深入"。总是对最近才发现的结点vvv的出发边进行探索，直到该结点的所有出发边都被发现为止。 一旦vvv的所有出发边都被发现，搜索则「回溯」到 vvv的前驱结点 (vvv是经过该结点才被发现的)，再搜索该前驱结点的其它出发边。 void dfs(int u) { //cout << u << ' '; st[u] = true; for (int i = h[u]; i != -1; i = ne[i]) {
DFS应用：SCC
weixin_30399871的博客
07-12 245
本文利用Kosaraju’s Two-Pass Algorithm 解决强连通子图问题。 Kosaraju算法是求解有向图强连通分量（strong connected component）的三个著名算法之一（另两个算法为Tarjan和Gabow），能在线性时间求解出一个图的强分量。三种算法具体的差别可参考：http://www.cppblog.com/koson/archive/20...
图的DFS算法
qq_36159303的博客
11-19 2886
DFS:depth-first-search 思想 访问图中的某一起始顶点v 由v出发，访问与v相连，并且没有被访问过的顶点w 访问与w相邻但是并没有被访问过的顶点x 重复2,3 当不能向下访问的时候，依次退回到最近被访问的顶点 访问直至所有顶点均被访问过 算法 bool visited[MAX_VERTEX_NUM]; //访问标记数组 void DFSTraverse(Graph G){ ...
图算法DFS
qq_43742531的博客
03-16 241
邻接矩阵1表示 伪代码 //访问顶点u void DFS(u) { visit[u] = true; //顶点u设置为已访问 for(从u出发能到达的所有顶点v){//遍历所有从u除法能到达的所有顶点v if visit[v]== false //如果未访问，则递归访问顶点v，DFS } } //遍历图 DFSTrave(G) { for(G的所有顶点u){ //遍历图的所有顶点 if visit[u] == false
【数据结构与算法学习】图的深度优先遍历（DFS算法）
翱翔于世纪的博客
08-14 5520
目录一、什么是图的遍历二、深度优先遍历（DFS）的基本思想三、深度优先遍历（DFS）的步骤详解及案例图解四、深度优先遍历（DFS）的代码实现 一、什么是图的遍历 图的遍历，指的是从图中的任一顶点出发，对图中的所有顶点访问一次且只访问一次。图的遍历操作和树的遍历操作功能相似。图的遍历是图的一种基本操作，图的许多其它操作都是建立在遍历操作的基础之上。 二、深度优先遍历（DFS）的基本思想 深度优先遍历（death first search）即DFS，从初始结点出发，初始结点可能会有多个邻接结点，访问完初始结点
DFS BFS 图.zip_DFS BFS_bfs_bfs dfs_dfs_dfs bfs输出图
09-20
深度优先遍历（DFS, Depth First Search）和广度优先遍历（BFS, Breadth First Search）是图论中的两种基本搜索算法，用于遍历或查找图中的所有节点。这两种算法都起始于图中的一个特定节点，通常称为起点，然后按照...
图——图的遍历（DFS与BFS算法详解）
Blusher1的博客
07-15 8821
前面的文章中我们学习了图的基本概念和存储结构，这篇文章就来学习一下图的重要章节——图的遍历。包含深度优先搜索（DFS）和广度优先搜索（BFS）两种方式。
算法领域DFS与BFS图遍历算法解析：核心思想、实现方式及应用场景比较
最新发布
04-10
内容概要：本文详细介绍了DFS（深度优先搜索）和BFS（广度优先搜索）这两种经典的图遍历算法。DFS的核心思想是从起点出发，尽可能深地访问节点，直到无法继续前进再回溯；而BFS则是从起点开始逐层向外扩展访问节点。...
基本图算法（bfs与dfs）1
08-04
"基本图算法（bfs与dfs）" 图算法是计算机科学中最重要的领域之一，许多问题可以被建模为图问题。图算法是解决这些问题的基础。 在图算法中，图是一种重要的数据结构，通常用来表示实世界中的关系。图可以被定义为...
数据结构——图的深度优先搜索算法（DFS）
koori_145的博客
02-13 4290
这篇专栏记录的是图的深度优先搜索算法（DFS）。（完整代码在最下面） 存储图，首先要定义边、顶点、图的结构体。 //边 typedef struct Edge{ int adj; //邻接点对应的的下标 Edge *next; //指向下一个结点 }Edge; //顶点 typedef struct{ int data; //顶点信息 Edge *firs...
【图计算算法‌】深度优先搜索（DFS）算法
大雨的博客
09-28 4676
深度优先搜索算法（Depth-First Search，简称DFS）是一种用于遍历或搜索树或图的算法。该算法沿着树的深度遍历树的节点，尽可能深地搜索树的分支。当节点v的所在边都已被探寻过，搜索将回溯到发现节点v的那条边的起始节点，这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为新的源节点并重复以上过程，直到所有节点都被访问为止。
数据结构与算法--图的深度优先搜索 (DFS)
李嘉图呀李嘉图的博客
04-02 4369
深度优先搜索即是 从起点出发，从规定的方向中选择一个不断往前走，走到头为止，然后尝试另一种方向直到最后的终点。 DFS解决的是连通性问题，即从A是否能到达B。采用DFS进行遍历的话，必须依赖栈，后进先出。 假设有一个图，里面有A、B、C、D、E、F、G、H 8 个顶点，对这个图进行深度优先的遍历 第一步选择一个起始顶点，例如从顶点 A 开始。把 A 压入栈，标记它为访问过（用红色标记），并输出到结果中。 第二步 寻找与 A 相连并且还没有被...
图算法二之DFS
山之巅的专栏
06-19 1079
图的DFS就是从图中某个顶点v出发，访问此顶点，然后从v的未被访问的邻接点出发深度优先遍历图，直至图中所有和v有路径想通的顶点都被访问到。 还是给个例子把，图形直观 其实图的DFS代码还是非常短的，关键是理解怎么遍历的，和BFS区别开，对于邻接矩阵，代码如下 void MGraphDFS(int i,struct MGraph *graph){ printf("当前顶点：%d\
【算法】经典图算法-dfs与bfs[深度/广度优先搜索]
Carol0630的博客
04-13 720
图的基本算法（BFS和DFS）
许恒的博客
12-28 1014
  图的基本算法（BFS和DFS）  卡巴拉的树  关注 2016.07.29 16:43* 字数 1103 阅读 24659评论 22喜欢 69赞赏 2 图是一种灵活的数据结构，一般作为一种模型用来定义对象之间的关系或联系。对象由顶点（V）表示，而对象之间的关系或者关联则通过图的边（E）来表示。 图可以分为有向图和无向图，一般用G=(V,E)来表示图。经常用邻接矩阵或者邻接表来描述一副图...
DFS与强联通分量(strong connected component-Sccs)
qq_14952615的博客
08-09 843
今天我们来聊一下DFS计算有向图的强联通分量Sccs。 老规矩，首先给出Sccs的定义。Sccs是一些节点的集合，该集合中任意两个节点u，v，存在路径u到v，同时也存在路径v到u。 我们来看一个示意图 我们看，a点存在一个到b的路径，b可以通过e点到达a。因此a b e构成了一个Sccs。 那么我们如何求解一个图中的Sccs呢？ 首先，我们将上图中的Sccs缩成一个点，来看看。 我们可以看到，将Sccs缩成一个点之后，示意图变简单了不少。如果我们对简化过后的示意图来进行搜索的话，我们..
Python:实现 卡恩拓扑algorithm topo算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
07-26 307
Python:实现 卡恩拓扑algorithm topo算法(附完整源码)
图遍历算法详解：BFS与DFS实现
对于图的遍历，主要有两种算法：深度优先搜索（DFS）和广度优先搜索（BFS）。在这次的上机作业中，我们将重点介绍这两种遍历算法。 深度优先搜索（DFS）是一种用于遍历或搜索树或图的算法。该算法沿着树的深度遍历...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值