常见图算法总结与Java实现

最新推荐文章于 2024-04-27 07:48:06 发布
最新推荐文章于 2024-04-27 07:48:06 发布
阅读量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
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java实现常见排序算法总结
05-02
主要是针对常见的排序算法进行分析实现
Java常用图形算法
HelloWorld搬运工
02-16 3046
本文介绍常用算法戴克斯特拉算法（Dijkstra’salgorithm），动态规划（Dynamic programming），朴素贝叶斯分类算法。 1、戴克斯特拉算法（Dijkstra’salgorithm） /*** * Dijkstra算法 * 算法步骤： * 1、第一轮，可以计算出，2、3、4、5、6到原点1的距离分别为：[7, 9, -1, -1, 14]。-1表示无穷...
JAVA 基础算法汇总（持续更新）
dayu199804的博客
04-14 1万+
前言 做一些基础数据结构算法汇总，便于日后复习。 一、查找算法 1.顺序查找（线性查找） 依据数组的下标按顺序进行查找，然后返回数组下标。对于数据量较小的情况，比较适用。但是如果数据量较大，花费的时间就比较多。 2.二分查找 二分查找Binary Search 二分查找的使用，要有一个前提条件：要查找的数必须在一个有序数组里。在这个前提下，取中间位置数作为比较对象： 若要查找的值和中间数相等，则查找成功。 若小于中间数，则在中间位置的左半区继续查找。 若大于中间数，则在中间位置...
Java语言常用的算法
最新发布
weixin_46228563的博客
04-27 306
Java语言常用的算法包括：排序算法：冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序等。查找算法：顺序查找、二分查找、哈希查找等。字符串匹配算法：暴力匹配、KMP算法、Boyer-Moore算法等。图论算法：最短路径算法、最小生成树算法、拓扑排序等。动态规划算法：背包问题、最长公共子序列、最长上升子序列等。贪心算法：最小生成树、单源最短路径等。分治算法：快速排序、归并排序等。网络流算法：最大流问题、最小割问题等。数学算法：欧几里得算法、素数判断、大数计算等。
Java实现图的基本操作
m0_53676388的博客
01-24 1154
1、分别定义图的邻接矩阵和邻接表存储结构； 2、分别在两种存储结构下根据输入的顶点和边（或弧）创建图； 3、分别在两种存储结构下实现求顶点度的操作； 4、分别在两种存储结构下实现图的深度和广度优先遍历算法； 5、实现图的邻接矩阵和邻接表存储结构的转换。
一篇文章轻松掌握java图实现
naititi的博客
12-29 1057
图的基本概念：这里就不予介绍了，这里主要是讲图的代码实现。
java图（含java图的代码）
qq_56127002的博客
08-29 1566
图的原理以及代码展示
详细总结各种排序算法(Java实现)
08-29
本篇文章将详细介绍几种常见的排序算法，并提供Java实现。 ### 1. 插入类排序 #### 1.1 直接插入排序 直接插入排序的基本思想是将每个元素插入到已排序的部分，保持其有序性。它的时间复杂度为O(n²)，空间复杂度...
algorithm:Java算法实现总结
05-11
"algorithm-master"项目可能包含了以上提到的各种算法的Java实现，通过阅读和学习该项目的源代码，你可以加深对这些算法的理解，提高编程能力。同时，对于每个算法，理解其时间复杂度和空间复杂度也非常重要，这有助...
java实现常见排序算法
03-02
总结起来，Java实现的插入排序和交换排序为程序员提供了处理各种数据排序问题的工具。了解和掌握这些排序算法不仅有助于提升编程能力，也是解决实际问题的基础，尤其是在大数据处理和性能优化方面。在实际应用中，...
java实现常见算法
05-01
在 Java 中，实现常见算法是非常重要的，以下是关于链表、约瑟环问题、单链表反转、最大子序列和问题、最大公因数、判断两个数组中是否有相同的数字、字符串反转等知识点的总结。 判断链表是否为循环链表 判断链表...
十五、图（深度优先遍历和广度优先遍历）
陈大大的博客
10-16 440
一、图基本介绍 二、图的表示方式 package graph; import java.util.ArrayList; import java.util.Arrays; import java.util.LinkedList; public class Graph { private ArrayList<String> vertexList; //存储顶点集合 private int[][] edges; //存储图对应的邻结矩阵 private int numOfEd
java实现图的创建与存储(邻接矩阵)
Groot-lin的博客
11-08 625
java实现图的创建即存储(邻接矩阵)
常见十四种的Java算法
热门推荐
心有谦谦结
04-17 3万+
一、简单列出常见的Java中14种算法 序号 简称 英文名称 简介 1 二分查找 Binary Search 二分查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。 2 冒泡排序 Bubble Sort 3 插入排序 4 快速排序 5 希尔排序 6 归并排序 7 桶排序 8 基数排序
java算法总结
qq_42575416的博客
06-19 319
java算法题简单总结
java实现图（邻接矩阵）
sokoooo的博客
01-06 3689
目录 一、图的知识点： 二、图的实现（都包含在Graph类中） 三、图的遍历（包含在类Graph中） （一） 深度优先遍历 （二） 广度优先遍历 一、图的知识点： 1. 图的概念：图是由顶点集合及顶点间的关系集合组成的一种数据结构。 2. 图的定义： G = (V, E) // V代表顶点的集合， E代表边的集合 V = {x | x ∈ 某个数据元素集合} E = {(x, y) | x, y ∈ V} // 无向图 或者 E = {<x, y> | x, y ∈ V 并且
图的表现形式第一篇（Java实现）
qq_37837621的博客
05-18 548
文章收藏的好句子：一直觉得当你足够努力，幸运总会和你不期而遇。目录1、图的表现形式 1、1 图的基本介绍 1、2图的表现形式 1、3图的深度优先遍历 1、3、1图的深度优先遍历的思想 1、3、2图的深度优先遍历的算法步骤1、图的表现形式1、1 图的基本介绍我们以前读大学的时候学过线性表和树，线性表局限于一...
Java经典算法详解-不来看看可惜咯
syh121的博客
09-09 113
正在学Java的各位这几种Java编程中的经典算法千万不要错过，算法在Java开发中会起到非常重要作用，了解这些常用的算法会让你在工作中达到事半功倍的效果！ 看看今天为大家整理经典算法详解： 一、插入排序 这是一个很好的理解打麻将或扑克。例如，如果左手中有一套卡1、2、4、7和一张3，则从右向左将此卡插入2、4是来验证否正确。 一次插入排序的操作过程： 将待插元素，依次与已排序好的子数列元素从后到前进行比较，如果当前元素值比待插元素值大，则将移位到与其相邻的后一个位置，否则直接将待插元素插入当前元

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值