图片视频违禁 java

转载

云端小悟空 2024-12-02 16:14:21

文章标签 图片视频违禁 java Java数据结构图论结点 List 文章分类 Java 后端开发

图的作用

图的定义

图的表示方式

代码实现

图的深度优先(DFS）

算法步骤

代码实现:

图的广度优先遍历(BFS)

算法步骤

代码实现

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

总结

图的作用

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

图的定义

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

图片视频违禁 java_结点

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

图片视频违禁 java_结点_02

带权图：边带权值的图

图片视频违禁 java_图片视频违禁 java_03

图的表示方式

邻接矩阵

图片视频违禁 java_图片视频违禁 java_04

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++;
	}	
}

图片视频违禁 java_结点_05

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

图片视频违禁 java_图论_06

图的深度优先(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++;
	}	
}

图片视频违禁 java_List_07