常见图算法总结与Java实现

最新推荐文章于 2024-09-17 08:00:00 发布
最新推荐文章于 2024-09-17 08:00:00 发布
阅读量2k 收藏 1
点赞数
分类专栏： 算法 文章标签： dijkstra kruskal prim java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zfyseu1/article/details/54973572
版权


下面的代码中实现了基于邻接表的图算法包括广度优先遍历、深度优先遍历、最小生成树算法Prim和Kruskal、单源最短路径算法Bellman-Ford和Dijkstra

代码参考算法导论和https://github.com/wangkuiwu/datastructs_and_algorithm/blob/master/source/graph/prim/udg/java/ListUDG.java


package Graph;

import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedList;

public class Graph {
	
	class ENode
	{
		int num;
		int weight=0;
		ENode nextEdge;
		ENode()
		{
			num=0;
			nextEdge=null;
		}
		ENode(int num)
		{
			this.num=num;
			nextEdge=null;
		}
		ENode(int num,int weight)
		{
			this.num=num;
			this.weight=weight;
			nextEdge=null;
		}
	}
	
	class VNode
	{
		char vertex;
		ENode firstEdge=null;
	}
	
	class Edge
	{
		char start;
		char end;
		int weight;
		
		Edge()
		{
			
		}
		
		Edge(Edge edge)
		{
			start=edge.start;
			end=edge.end;
			weight=edge.weight;
		}
		
		Edge(char start,char end,int weight)
		{
			this.start=start;
			this.end=end;
			this.weight=weight;
		}
		
	}
	
	VNode[] mVertex;
	Edge[] medges;
	int edgeNum=0;
	int[][] mWeights;
	static int INF = Integer.MAX_VALUE;
	
	public int vertexToNum(char c)
	{
		int res=0;
		for(int i=0;i<mVertex.length;i++)
		{
			if(mVertex[i].vertex==c)
				return i;
		}
		return res;
	}
	
	public Graph(char[] vexs,char[][] edges)
	{
		edgeNum=edges.length;
		mVertex=new VNode[vexs.length];
		for(int i=0;i<vexs.length;i++)
		{
			mVertex[i]=new VNode();
			mVertex[i].vertex=vexs[i];
		}
		for(int i=0;i<edges.length;i++)
		{
			ENode temp=new ENode(vertexToNum(edges[i][1]));
			
			if(mVertex[vertexToNum(edges[i][0])].firstEdge==null)
			{
				mVertex[vertexToNum(edges[i][0])].firstEdge=temp;
			}
			else
			{
				ENode p=mVertex[vertexToNum(edges[i][0])].firstEdge;
				
				while(p.nextEdge!=null)
				{
					p=p.nextEdge;
				}
				p.nextEdge=temp;
			}	
		}
	}
	
	Graph(char[] vexs,char[][] edges,int[] weights,Boolean isDirected)
	{
		edgeNum=edges.length;
		medges=new Edge[edgeNum];
		
		mWeights=new int[vexs.length][vexs.length];
		for(int i=0;i<vexs.length;i++)
		{
			for(int j=0;j<vexs.length;j++)
			{
				mWeights[i][j]=INF;
			}
		}
		
		mVertex=new VNode[vexs.length];
		for(int i=0;i<vexs.length;i++)
		{
			mVertex[i]=new VNode();
			mVertex[i].vertex=vexs[i];
		}
		for(int i=0;i<edges.length;i++)
		{
			ENode temp=new ENode(vertexToNum(edges[i][1]),weights[i]);
			medges[i]=new Edge(edges[i][0],edges[i][1],weights[i]);
			mWeights[vertexToNum(edges[i][0])][vertexToNum(edges[i][1])]=weights[i];
			
			if(mVertex[vertexToNum(edges[i][0])].firstEdge==null)
			{
				mVertex[vertexToNum(edges[i][0])].firstEdge=temp;
			}
			else
			{
				ENode p=mVertex[vertexToNum(edges[i][0])].firstEdge;
				
				while(p.nextEdge!=null)
				{
					p=p.nextEdge;
				}
				p.nextEdge=temp;
			}	
			
			if(!isDirected)
			{
				temp=new ENode(vertexToNum(edges[i][0]),weights[i]);
				mWeights[vertexToNum(edges[i][1])][vertexToNum(edges[i][0])]=weights[i];
			
				if(mVertex[vertexToNum(edges[i][1])].firstEdge==null)
				{
					mVertex[vertexToNum(edges[i][1])].firstEdge=temp;
				}
				else
				{
					ENode p=mVertex[vertexToNum(edges[i][1])].firstEdge;
				
					while(p.nextEdge!=null)
					{
						p=p.nextEdge;
					}
					p.nextEdge=temp;
				}
			}
			
		}
	}
	
	
	public void BFS()
	{
		LinkedList<VNode> queue=new LinkedList<VNode>();
		Boolean[] isVisited=new Boolean[mVertex.length];
		for(int i=0;i<mVertex.length;i++)
		{
			isVisited[i]=false;
		}
		queue.offer(mVertex[0]);
		System.out.print(mVertex[0].vertex+" ");
		isVisited[0]=true;
		while(!queue.isEmpty())
		{
			VNode p=queue.remove(); 
			ENode q=p.firstEdge;
			while(q!=null)
			{
				if(!isVisited[q.num])
				{
					isVisited[q.num]=true;
					System.out.print(mVertex[q.num].vertex+" ");
					queue.offer(mVertex[q.num]);
				}
				q=q.nextEdge;
			}
		}
		System.out.println();
	}
	
	public void DFSfirst(VNode vertex,Boolean[] isVisited){
		int num=vertexToNum(vertex.vertex);
		if(!isVisited[num])
		{
			isVisited[num]=true;
			System.out.print(vertex.vertex+" ");
		}
		ENode p=vertex.firstEdge;
		while(p!=null)
		{
			DFSfirst(mVertex[p.num],isVisited);
			p=p.nextEdge;
		}	
	}
	
	public void DFS()
	{
		Boolean[] isVisited=new Boolean[mVertex.length];
		for(int i=0;i<mVertex.length;i++)
		{
			isVisited[i]=false;
		}
		for(int i=0;i<mVertex.length;i++)
		{
			if(!isVisited[i])
				DFSfirst(mVertex[i],isVisited);
		}
		System.out.println();
		
	}
	
	
	//walk all the edges in the nondecreasing order of weight
	public Edge[] Kruskal()
	{
		Edge[] res=new Edge[mVertex.length-1];
		if(edgeNum<1) return res;
		
		//bubble sort
		for(int i=0;i<edgeNum-1;i++)
		{
			for(int j=edgeNum-1;j>i;j--)
			{
				if(medges[j].weight<medges[j-1].weight)
				{
					Edge temp;
					temp=medges[j];
					medges[j]=medges[j-1];
					medges[j-1]=temp;
				}
			}
		}
		
		int j=0;
		char[] vends=new char[mVertex.length];
		for(int i=0;i<vends.length;i++)
		{
			vends[i]=mVertex[i].vertex;
		}
		for(int i=0;i<edgeNum;i++)
		{
			int s=vertexToNum(medges[i].start);
			int e=vertexToNum(medges[i].end);
			if(vends[s]!=vends[e])
			{
				char temp_c=vends[s];
				for(int k=0;k<vends.length;k++)
				{
					if(vends[k]==temp_c)
						vends[k]=vends[e];
				}
				res[j]=medges[i];
				j++;
			}
		}
		
		int length = 0;
        for (int i = 0; i < res.length; i++)
            length += res[i].weight;
        System.out.printf("Kruskal=%d: ", length);
        for (int i = 0; i < res.length; i++)
            System.out.printf("(%c,%c) ", res[i].start, res[i].end);
        System.out.printf("\n");
		return res;
	}
	
	
	public void Prim(char c)
	{
		int pos=vertexToNum(c);
		char[] res=new char[mVertex.length];
		int[] key=new int[mVertex.length];
		int[] front=new int[mVertex.length];
		int minKey=INF,minPos=0;
		for(int i=0;i<mVertex.length;i++)
		{
			key[i]=mWeights[pos][i];
			front[i]=-1;
			if(key[i]<minKey)
			{
				minKey=key[i];
				minPos=i;
			}
		}
		front[minPos]=pos;
		key[pos]=0;
		res[0]=mVertex[pos].vertex;
		
		
		int i=0,k=1,sum=0;
		while(i++<mVertex.length-1)
		{
			minKey=INF;
			for(int j=0;j<mVertex.length;j++)
			{
				if(key[j]!=0&&key[j]<minKey)
				{
					minPos=j;
					minKey=key[j];
				}
			}
			res[k++]=mVertex[minPos].vertex;
			sum=sum+mWeights[front[vertexToNum(res[k-1])]][vertexToNum(res[k-1])];
			
			key[minPos]=0;
			for(int j=0;j<mVertex.length;j++)
			{
				if(key[j]!=0&&mWeights[minPos][j]<key[j])
				{
					key[j]=mWeights[minPos][j];
					front[j]=minPos;
				}
			}
		}
		
		 System.out.printf("PRIM(%c)=%d: ", mVertex[pos].vertex, sum);
	        for (i = 0; i < mVertex.length; i++)
	            System.out.printf("%c ", res[i]);
	        System.out.printf("\n");
	}
	
	
	public Boolean BellmanFord(char c)
	{
		int s=vertexToNum(c);
		int[] d=new int[mVertex.length];
		int[] front=new int[mVertex.length];
		
		for(int i=0;i<mVertex.length;i++)
		{
			d[i]=INF;
			front[i]=-1;
		}
		d[s]=0;
		
		for(int i=0;i<mVertex.length-1;i++)
		{
			for(int j=0;j<edgeNum;j++)
			{
				int start=vertexToNum(medges[j].start);
				int end=vertexToNum(medges[j].end);
				if(d[end]>d[start]+mWeights[start][end])
				{
					d[end]=d[start]+mWeights[start][end];
					front[end]=start;
				}
			}
		}
		
		for(int i=0;i<edgeNum;i++)
		{
			int start=vertexToNum(medges[i].start);
			int end=vertexToNum(medges[i].end);
			if(d[end]>d[start]+mWeights[start][end])
			{
				return false;
			}
		}
		
		System.out.printf("BellmanFord:  ");
		for(int i=0;i<mVertex.length;i++)
		{
			if(i==s) continue;
			System.out.print(mVertex[front[i]].vertex+" ");
		}
		System.out.println();
		return true;
	}
	
	public void Dijkstra(char c)
	{
		int s=vertexToNum(c);
		int[] S=new int[mVertex.length];
		int[] d=new int[mVertex.length];
		int[] front=new int[mVertex.length];
		
		for(int i=0;i<mVertex.length;i++)
		{
			d[i]=INF;
			S[i]=-1;
			front[i]=-1;
		}
		d[s]=0;

		//use array d[] to implement PriorityQueue
		int minPos=s,minD=INF;
		for(int i=0;i<mVertex.length;i++)
		{
			minD=INF;
			for(int j=0;j<mVertex.length;j++)
			{
				if(d[j]!=0&&d[j]<minD)
				{
					minD=d[j];
					minPos=j;
				}
			}
			d[minPos]=0;
			
			int start=minPos;
			int end=0;
			ENode p=mVertex[start].firstEdge;
			while(p!=null)
			{
				end=p.num;
				if(d[end]>d[start]+mWeights[start][end])
				{
					d[end]=d[start]+mWeights[start][end];
					front[end]=start;
				}
				p=p.nextEdge;
			}
			
		}
		
		System.out.printf("Dijkstra:  ");
		for(int i=0;i<mVertex.length;i++)
		{
			if(i==s) continue;
			System.out.print(mVertex[front[i]].vertex+" ");
		}
		System.out.println();
		
	}
	
	public void printGraph()
	{
		for(int i=0;i<mVertex.length;i++)
		{
			System.out.printf("%d%c:", i,mVertex[i].vertex);
			ENode p=mVertex[i].firstEdge;
			while(p!=null)
			{
				System.out.printf("%d%c(%d) ", p.num,mVertex[p.num].vertex,p.weight);
				p=p.nextEdge;
			}
			System.out.println();
		}
	}
	
	public static void main(String[] args)
	{
		char[] vexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        char[][] edges = new char[][]{
            {'A', 'C'}, 
            {'A', 'D'}, 
            {'A', 'F'}, 
            {'B', 'C'}, 
            {'C', 'D'}, 
            {'E', 'G'}, 
            {'F', 'G'}};
		Graph mgraph=new Graph(vexs,edges);
		mgraph.printGraph();
		mgraph.BFS();
		mgraph.DFS();
		
		
		char[] vexs2={'A', 'B', 'C', 'D', 'E', 'F', 'G'};
		char[][] edges2=
			{
					{'A','B'},
					{'A','F'},
					{'A','G'},
					{'B','C'},
					{'B','F'},
					{'C','D'},
					{'C','E'},
					{'C','F'},
					{'D','E'},
					{'E','F'},
					{'E','G'},
					{'F','G'},
			};
		int[] weight2={12,16,14,10,7,3,5,6,4,2,8,9};
		
		Graph mgraph2=new Graph(vexs2,edges2,weight2,false);
		mgraph2.printGraph();
		mgraph2.Kruskal();
		mgraph2.Prim('A');
		
		char[] vexs3={'s','t','x','y','z'};
		char[][] edges3=
			{
					{'s','t'},
					{'s','y'},
					{'t','x'},
					{'t','y'},
					{'t','z'},
					{'x','t'},
					{'y','x'},
					{'y','z'},
					{'z','s'},
					{'z','x'}
			};
		
		int[] weights3={6,7,5,8,-4,-2,-3,9,2,7};
		
		Graph mgraph3=new Graph(vexs3,edges3,weights3,true);
		mgraph3.printGraph();
		mgraph3.BellmanFord('s');
		
		char[] vexs4={'s','t','x','y','z'};
		char[][] edges4=
			{
					{'s','t'},
					{'s','y'},
					{'t','x'},
					{'t','y'},
					{'x','z'},
					{'y','t'},
					{'y','x'},
					{'y','z'},
					{'z','s'},
					{'z','x'}
			};
		int[] weights4={10,5,1,2,4,3,9,2,7,6};
		Graph mgraph4=new Graph(vexs4,edges4,weights4,true);
		mgraph4.Dijkstra('s');
		mgraph4.BellmanFord('s');
	}
}


zfyseu1
关注
专栏目录
Java实现常见排序算法总结
05-02
【Java实现常见排序算法总结】 排序算法是计算机科学中至关重要的一部分，它涉及到数据处理和算法设计。本文将探讨两种常见的排序算法在Java中的实现：直接插入排序和希尔排序。 1. **直接插入排序（直接插入排序...
java利用DFA算法实现敏感词过滤功能
08-30
在本文中，我们将探讨如何使用DFA（有穷自动机）算法在Java中实现敏感词过滤功能。敏感词过滤在许多应用程序中都是必要的，例如社交媒体、论坛或博客平台，以防止用户发布不当或有害的内容。以下是对DFA算法及其在...
常见图算法思想
时间有泪
12-07 521
文章目录1 最小生成树1.1 普里姆算法(Prim)1.2 克鲁斯卡尔算法(Kruskal)2 最短路径2.1 迪杰斯特拉算法(Dijkstra)2.2 弗洛伊德算法(Floyd) 1 最小生成树 生成树：图有n个结点，用n-1条边连接起来。 最小生成树：代价最小的生成树。 1.1 普里姆算法(Prim) 点扩展：有一个集合和其他节点。 刚开始，起点在这个集合中，找到到这个集合的最短距离的节点，将...
Java算法总结
最新发布
weixin_44063529的博客
09-17 417
这篇文章是一篇Java算法总结，涵盖了链表、动态规划、位运算、回溯算法和双指针等主题。文章详细讨论了链表的逆序打印、Josephus问题、斐波那契数列、青蛙上台阶问题、二进制中1的个数、打印1到最大的n位数以及单链表反转和链表中倒数第k个节点的算法实现。每个部分都提供了代码示例，帮助读者理解算法原理和实现方式。作者还提供了一些优化技巧和算法的变体，使文章成为Java算法学习的宝贵资源。
图的几种常见的算法
J__King的专栏
09-10 2261
1、拓扑排序 找到图中没有输入只有输出的点，
图及其常见算法
weixin_45565886的博客
09-01 742
图及其常见算法
常见的算法技巧——图算法
qq_45902301的博客
07-10 1071
这篇文章介绍了常见的算法技巧——图算法。
常用加密算法的Java实现总结(二)——对称加密算法DES、3DES和AES.pdf
02-10
对称加密算法包括了多种算法，本文主要介绍DES、3DES和AES这三种常见的对称加密算法，并对它们进行Java实现的总结。 首先，对称加密算法的一个关键优势在于其算法公开、计算量小、加密速度快、加密效率高，但它们也...
Java实现的两种常见简单查找算法示例【快速查找与二分查找】
08-29
Java实现的两种常见简单查找算法示例【快速查找与二分查找】 查找算法是计算机科学中的一种基本算法，它可以在大量数据中快速地找到指定的数据。在 Java 中，有多种查找算法，以下我们将介绍两种常见的简单查找算法...
网络图计算方法（个人总结，通俗易懂）
05-23
在系统集成项目管理工程师的考试中，有2类计算题。一个是网络图的计算，一个是挣值分析。其中网络图的计算很多同学都容易搞乱搞混，为此写了一个文档，按照这个规则一步一步的计算，保准大家都学会计算，顺利通过考试。网络图的计算关键是找准几个点和计算的方向。挣值分析的计算方法稍后再做整理。
Java图遍历算法一例
12-07
java图遍历应用一例： 题目：用1、2、2、3、4、5这六个数字，用java写一个函数，打印出所有不同的排列，如：512234、412345等，要求："4"不能在第三位，"3"与"5"不能相连。
二叉树和图的常用算法操作.zip
08-16
主要包含二叉树的添加 查找 深度搜索 层次遍历 先序 后序中序遍历及图的深度搜索等常用算法
Java图片上查找图片算法
01-21
之前用按键精灵写过一些游戏辅助，里面有个函数叫FindPic，上在屏幕范围查找给定的一张图片，返回查找到的坐标位置。 　　现在，Java来实现这个函数类似的功能。 　　算法描述： 　　屏幕截图，得到图A，(查找的目标图片为图B)； 　　遍历图A的像素点，根据图B的尺寸，得到图B四个角映射到图A上的四个点； 　　得到的四个点与图B的四个角像素点的值比较。如果四个点一样，执行步骤4；否则，回到步骤2继续； 　　进一步对比，将映射范围内的全部点与图B全部的点比较。如果全部一样，则说明图片已找到；否则，回到步骤2继续； 　　这里，像素之间的比较是通过BufferedImage对象获取每个
JAVA 知识汇总图的总结
static_asd的博客
06-04 163
总结 JAVA 知识汇总图 List item
图算法
t_jianyan的博客
07-03 244
两种储存方式优缺点比较邻接矩阵的优点是可以快速判断两个顶点之间是否存在边，可以快速添加边或者删除边。而其缺点是如果顶点之间的边比较少，会比较浪费空间。因为是一个 n∗nn∗n 的矩阵。而邻接表的优点是节省空间，只存储实际存在的边。其缺点是关注顶点的度时，就可能需要遍历一个链表。还有一个缺点是，对于无向图，如果需要删除一条边，就需要在两个链表上查找并删除。点击打开链接两种遍历方式深度：点击打开链接广...
Java-图的遍历模式
qq_45739810的博客
11-08 200
图遍历介绍 所谓图的遍历，即是对节点的访问，一个图有那么多节点，如何遍历这些节点，需要特定策略，一般有两种访问策略：1.深度优先遍历2.广度优先遍历 深度优先遍历基本思想 1.深度优先遍历，从初始访问节点出发，初始访问节点可能有很多邻接节点，深度优先遍历的策略就是首先访问第一个邻接节点，然后再以这个被访问的邻接节点作为初始节点，访问它的第一个邻接节点，可以这样理解，每次都在访问完当前节点后首先访问当前节点的第一个邻接节点 2.我们可以看到，这样的访问策略是优先往纵向深入挖掘，而不是对一个节点的所有邻接节点进
图算法总结
ak47fourier的博客
08-03 794
Dijkstra算法 1)一旦找到从S到顶点P的最短路径，这条最短路径的所有中间节点的最短路径也知道了！ 从S到D的最短路径是一定存在的，假设已经找到了这条路径，它是S-a-b-c-d-e-…-D。那么立即确定： S到a的最短路径就是S-a S到b的最短路径就是S-a-b S到c的最短路径就是S-a-b-c … 证明： 假设S到a的最短路径不是S-a，而是经过了其它的节点，比如...
JAVA排序算法总结与实现
"JAVA排序汇总，此资源是一个Java程序，将常见的排序算法进行了归纳和实现，包括冒泡排序、选择排序、插入排序、快速排序以及希尔排序等。它旨在帮助学习者理解和比较不同排序算法的效率和应用场景。" 在编程领域，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值