图的视频笔记(java)

最新推荐文章于 2024-06-28 16:20:42 发布

小吴有想法

最新推荐文章于 2024-06-28 16:20:42 发布

阅读量273

点赞数 10

分类专栏： java 文章标签： Java数据结构图论

本文链接：https://blog.csdn.net/Wuweihendidiao/article/details/123644481

版权

java 专栏收录该内容

26 篇文章 3 订阅

订阅专栏

学习视频：【尚硅谷】数据结构与算法（Java数据结构与算法）_哔哩哔哩_bilibili

图的作用

线性表局限于一个直接前驱和一个直接后驱
树也只能有一个直接前驱也就是父结点
当我们需要多对多的关系时，就需要用图

图的定义

图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。结点也可以称为顶点。

有向图：顶点之间的连接有方向

带权图：边带权值的图

图的表示方式

邻接矩阵

1表示能直接连接
0表示不能直接连接

存储结点String
保存矩阵int [][] edges;

代码实现

import java.util.ArrayList;
import java.util.Arrays;

public class Graph {

	private ArrayList<String> vertexList;//存储结点集合
	private int [][]edges;//存储图对应的邻接矩阵
	private int numOfEdges;//表示边的数目
	
	public static void main(String[] args)
	{
		//测试
		int n=5;//n为结点个数
		String VertexValue[]= {"A","B","C","D","E"};
		//创建图对象
	Graph graph=new Graph(n);
		//循环的添加结点
		for(String value:VertexValue)
		{
			graph.insertVertex(value);
		}
		//添加边
		graph.insertEdge(0, 1, 1);
		graph.insertEdge(0, 2, 1);
		graph.insertEdge(1, 2, 1);
		graph.insertEdge(1, 3, 1);
		graph.insertEdge(1, 4, 1);
		
		//显示
		graph.showGraph();
			
	}
	
	//构造器初始化
	public Graph(int n)
	{
		edges=new int[n][n];
		vertexList=new  ArrayList<String>(n);
		numOfEdges=0;
		
	}
	//返回结点的个数
	public int getNumOfVertex()
	{
		return vertexList.size();
	}
	//显示图对应的矩阵
	public void showGraph()
	{
		for(int[] link:edges)
		{
			System.out.println(Arrays.toString(link));
		}
	}
	//得到边的数目
	public int getNumOfEdges()
	{
		return numOfEdges;
	}
	//返回结点i对应的数据 0->A 1—>B 2->C
	public String getValueByIndex(int i)
	{
		return vertexList.get(i);
		
	}
	//返回v1和v2的权值
	public int getWeight(int v1,int v2)
	{
		return edges[v1][v2];
	}
	//插入结点
	public void insertVertex(String vertex)
	{
		vertexList.add(vertex);
	}
	/*
	 * v1 表示点的下标，即是第几个顶点'A'-'B' 'A'->0 'B'->1
	 * v2表示第二个顶点对应的下标
	 * weight
	 */
	//添加边
	public void insertEdge(int v1,int v2,int weight)
	{
		edges[v1][v2]=weight;
		edges[v2][v1]=weight;
		numOfEdges++;
	}	
}

邻接表:

邻接矩阵需要为每个顶点都分配n个边的空间，其实有很多边都是不存在的，会造成空间的一定损失
邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间的浪费，邻接表由数组+链表组成

图的深度优先(DFS）

图的深度优先搜索：

深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点，可以这样理解：每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。
这样的访问是优先纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问
显然，深度优先搜索是一个递归过程

算法步骤

访问初始结点v,并标记结点v为已访问。
查找结点v的第一个邻接结点w.
若w存在，则继续执行4,如果w不存在，则回到第一步，将从v的下一个结点继续
若w未被访问，对w进行深度优先遍历递归(即把w当作另一个v,然后进行步骤123)
查找结点v的w邻接结点的下一个邻接结点，转到步骤3

代码实现:

import java.util.ArrayList;
import java.util.Arrays;

public class Graph {

	private ArrayList<String> vertexList;//存储结点集合
	private int [][]edges;//存储图对应的邻接矩阵
	private int numOfEdges;//表示边的数目
	//定义一个boolean数组，记录某个结点是否被访问过
	private boolean[] isVisited;
	public static void main(String[] args)
	{
		//测试
		int n=5;//n为结点个数
		String VertexValue[]= {"A","B","C","D","E"};
		//创建图对象
	Graph graph=new Graph(n);
		//循环的添加结点
		for(String value:VertexValue)
		{
			graph.insertVertex(value);
		}
		//添加边
		graph.insertEdge(0, 1, 1);
		graph.insertEdge(0, 2, 1);
		graph.insertEdge(1, 2, 1);
		graph.insertEdge(1, 3, 1);
		graph.insertEdge(1, 4, 1);
		
		//显示
		graph.showGraph();
			
		//测试dfs遍历
		System.out.println("深度遍历");
		graph.dfs();//
		
	}
	
	//构造器初始化
	public Graph(int n)
	{
		edges=new int[n][n];
		vertexList=new  ArrayList<String>(n);
		numOfEdges=0;
		isVisited=new boolean[5];
		
	}
	//返回结点的个数
	public int getNumOfVertex()
	{
		return vertexList.size();
	}
	/*
	 * @return 如果存在就返回对应的下标，否则返回-1
	 */
	//得到第一个邻接结点的下标w
	public int getfirst(int index)
	{
		for(int j=0;j<vertexList.size();j++)
		{
			if(edges[index][j]>0)
			{
				return j;
			}
		}
		return -1;
	}
	//根据前一个邻接结点的下标来获取下一个邻接结点
	public int getnext(int v1,int v2)//v1和v2是上一个结点的横纵坐标
	{
		for(int j=v2+1;j<vertexList.size();j++)
		{
			if(edges[v1][j]>0)
			{
				return j;
			}
		}
		return -1;	
	}
	public void dfs(boolean[] isVisited,int i) 
	{
		//首先访问该结点并输出
		System.out.print(getValueByIndex(i)+"->");
		//将该结点设置为已访问
		isVisited[i] =true;
		//查找结点V的第一个邻接结点w
		int w=getfirst(i);
		while(w!=-1)
		{
			if(!isVisited[w])
			{
				dfs(isVisited,w);
			}
			//如果w已经被访问，查找下一个结点
			w=getnext(i,w);
		}
	}
	//对dfs 进行一个重载,遍历所有的结点，并进行dfs
	public void dfs()
	{
		//遍历所有的结点，进行dfs回溯
		for(int i=0;i<getNumOfVertex();i++)
		{
			if(!isVisited[i])
			{
				dfs(isVisited,i);
			}
		}
	}
	//显示图对应的矩阵
	public void showGraph()
	{
		for(int[] link:edges)
		{
			System.out.println(Arrays.toString(link));
		}
	}
	//得到边的数目
	public int getNumOfEdges()
	{
		return numOfEdges;
	}
	//返回结点i对应的数据 0->A 1—>B 2->C
	public String getValueByIndex(int i)
	{
		return vertexList.get(i);
		
	}
	//返回v1和v2的权值
	public int getWeight(int v1,int v2)
	{
		return edges[v1][v2];
	}
	//插入结点
	public void insertVertex(String vertex)
	{
		vertexList.add(vertex);
	}
	/*
	 * v1 表示点的下标，即是第几个顶点'A'-'B' 'A'->0 'B'->1
	 * v2表示第二个顶点对应的下标
	 * weight
	 */
	//添加边
	public void insertEdge(int v1,int v2,int weight)
	{
		edges[v1][v2]=weight;
		edges[v2][v1]=weight;
		numOfEdges++;
	}	
}

图的广度优先遍历(BFS)

图的广度优先搜索类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来访问这些结点的邻接结点

算法步骤

访问初始结点V并标记结点V为已访问
结点V入队
当队列非空时，继续执行，否则算法结束（仅仅是对这个结点）
出队列，取得队头结点u
查找结点u的第一个邻接结点w
若结点u的邻接结点w不存在，则转到步骤3；否则循环执行一下三个步骤：

若结点w尚未被访问，则访问结点w并标记为已访问
结点w入队列
查找结点u的继w邻接结点后的下一个邻接结点w，转到步骤6

代码实现

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;

public class Graph {

	private ArrayList<String> vertexList;//存储结点集合
	private int [][]edges;//存储图对应的邻接矩阵
	private int numOfEdges;//表示边的数目
	//定义一个boolean数组，记录某个结点是否被访问过
	private boolean[] isVisited;
	public static void main(String[] args)
	{
		//测试
		int n=5;//n为结点个数
		String VertexValue[]= {"A","B","C","D","E"};
		//创建图对象
	Graph graph=new Graph(n);
		//循环的添加结点
		for(String value:VertexValue)
		{
			graph.insertVertex(value);
		}
		//添加边
		graph.insertEdge(0, 1, 1);
		graph.insertEdge(0, 2, 1);
		graph.insertEdge(1, 2, 1);
		graph.insertEdge(1, 3, 1);
		graph.insertEdge(1, 4, 1);
		
		//显示
		graph.showGraph();
			
		//测试dfs遍历
		/*
		 * System.out.println("深度遍历"); graph.dfs();//
		 * 
		 */		
		System.out.println("广度优先");
		graph.bfs();
	}
	
	//构造器初始化
	public Graph(int n)
	{
		edges=new int[n][n];
		vertexList=new  ArrayList<String>(n);
		numOfEdges=0;
		isVisited=new boolean[5];
		
	}
	//返回结点的个数
	public int getNumOfVertex()
	{
		return vertexList.size();
	}
	/*
	 * @return 如果存在就返回对应的下标，否则返回-1
	 */
	//得到第一个邻接结点的下标w
	public int getfirst(int index)
	{
		for(int j=0;j<vertexList.size();j++)
		{
			if(edges[index][j]>0)
			{
				return j;
			}
		}
		return -1;
	}
	//根据前一个邻接结点的下标来获取下一个邻接结点
	public int getnext(int v1,int v2)//v1和v2是上一个结点的横纵坐标
	{
		for(int j=v2+1;j<vertexList.size();j++)
		{
			if(edges[v1][j]>0)
			{
				return j;
			}
		}
		return -1;	
	}
	public void dfs(boolean[] isVisited,int i) 
	{
		//首先访问该结点并输出
		System.out.print(getValueByIndex(i)+"->");
		//将该结点设置为已访问
		isVisited[i] =true;
		//查找结点V的第一个邻接结点w
		int w=getfirst(i);
		while(w!=-1)
		{
			if(!isVisited[w])
			{
				dfs(isVisited,w);
			}
			//如果w已经被访问，查找下一个结点
			w=getnext(i,w);
		}
	}
	//对dfs 进行一个重载,遍历所有的结点，并进行dfs
	public void dfs()
	{
		//遍历所有的结点，进行dfs回溯
		for(int i=0;i<getNumOfVertex();i++)
		{
			if(!isVisited[i])
			{
				dfs(isVisited,i);
			}
		}
	}
	//对一个结点进行广度优先遍历的方法
	 public void bfs(boolean [] isVisited,int i)
	 {
		 int u;//表示队列的头结点对应下标
		 int w;//邻接结点 w
		 //队列，结点访问的顺序
		LinkedList queue= new LinkedList();
		//访问结点，输出结点的信息
		System.out.print(getValueByIndex(i)+"->");
		//标记为已访问
		isVisited[i]=true;
		//将结点加入队列
		queue.addLast(i);
		
		while(!queue.isEmpty())
		{
			//取出队列的头结点下标
		u=(Integer)queue.removeFirst();
		//得到第一个邻结点的下标w
		w=getfirst(u);
		while(w!=-1)
		{
			//找到
			//是否访问过
			if(!isVisited[w])
			{
				System.out.print(getValueByIndex(w)+"->");
				isVisited[w]=true;
				//入队
				queue.addLast(w);
			}
			//以u为前驱点，找w后面的下一个邻结点
			w=getnext(u,w);//体现广度优先	
		}
	}	 
}
	//遍历所有的结点，都进行广度优先搜索
	 public void bfs()
	 {
		for(int i=0;i<getNumOfVertex();i++)
		{
			if(!isVisited[i])
			{
				bfs(isVisited,i);
			}
		}
	 }	
	//显示图对应的矩阵
	public void showGraph()
	{
		for(int[] link:edges)
		{
			System.out.println(Arrays.toString(link));
		}
	}
	//得到边的数目
	public int getNumOfEdges()
	{
		return numOfEdges;
	}
	//返回结点i对应的数据 0->A 1—>B 2->C
	public String getValueByIndex(int i)
	{
		return vertexList.get(i);
		
	}
	//返回v1和v2的权值
	public int getWeight(int v1,int v2)
	{
		return edges[v1][v2];
	}
	//插入结点
	public void insertVertex(String vertex)
	{
		vertexList.add(vertex);
	}
	/*
	 * v1 表示点的下标，即是第几个顶点'A'-'B' 'A'->0 'B'->1
	 * v2表示第二个顶点对应的下标
	 * weight
	 */
	//添加边
	public void insertEdge(int v1,int v2,int weight)
	{
		edges[v1][v2]=weight;
		edges[v2][v1]=weight;
		numOfEdges++;
	}	
}

广度优先和深度优先的区别

总结

DFS相当于前序遍历

BFS相当于层序遍历

学习如逆水行舟，不进则退。和小吴一起加油吧！

小吴有想法

关注

10
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
10
评论
图的视频笔记(java)

学习视频：【尚硅谷】数据结构与算法（Java数据结构与算法）_哔哩哔哩_bilibili图的作用线性表局限于一个直接前驱和一个直接后驱树也只能有一个直接前驱也就是父结点当我们需要多对多的关系时，就需要用图图的定义图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。结点也可以称为顶点。有向图：顶点之间的连接有方向带权图：边带权值的图图的表示方式邻接矩阵1表示能直接连接 0表示不能直接...
复制链接

扫一扫