图的深度遍历和广度遍历（JAVA）

package Graph_tu;

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

public class Gragh {

	private ArrayList<String>vertexList;//存储节点
	private int[][]edges;//存储邻接矩阵
	private int numofEdges;
	private static boolean[] isVisited;//判断节点是否访问
	
	//构造
	public Gragh(int n)  {
	vertexList=new ArrayList<String>(n);
	edges=new int[n][n];
	numofEdges=0;
	}
	
	//节点数
	public int getnumofVertex() {
		return vertexList.size();
	}
	//边数
	public int getnumofEdges() {
		return numofEdges;
	}
	//节点i
	public String getValueofIndex(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);
	}
	
	//添加边
	public void insertEdge(int v1,int v2,int w) {
		edges[v1][v2]=w;
		edges[v2][v1]=w;
		numofEdges++;
	}
	
	//得到第一个结点的下标
	public int getfirstNeighbor(int index) {
		for(int j=0;j<vertexList.size();j++) {
			if(edges[index][j]>0) {
				return j;
			}
		}
		return -1;
	}
	
	//根据前一个邻接节点的下标获取下一个节点(获取v1除v2之外的邻接点)
	public int getNextneighbor(int v1,int v2) {
		for(int j=v2+1;j<vertexList.size();j++) {
			if(edges[v1][j]>0)
				return j;
		}
		return -1;
	}
	
	//显示图的邻接矩阵
	public void showGraph() {
		for(int[] i:edges) {
			System.out.println(Arrays.toString(i));//形式？？？
		}
	}
	//深度搜索（存在递归调用）
	public void dfs(boolean[] isvisited,int i) {
		//1.访问输出该节点
		System.out.print(getValueofIndex(i)+"--》");
		//2.设置为已访问
		isvisited[i]=true;
		//3.寻找该节点的第一个邻接点
		int w=getfirstNeighbor(i);
		//4.若w存在
		while(w!=-1) {
		//5.若未被访问过
			if(!isvisited[w]) {
				dfs(isvisited,w);
			}
		//6.若已被访问过
			w=getNextneighbor(i, w);
		}
	}
	
	//重载dfs
	public void dfs() {
		isVisited=new boolean[vertexList.size()];
		for(int i=0;i<getnumofVertex();i++) {
			if(!isVisited[i])
			dfs(isVisited,i);
		}
	}
	
	//广度搜索
	public void bfs(boolean isVisited[],int i) {
		int u;
		int w;
		//存标号
		LinkedList<Integer> queue=new<Integer> LinkedList();
		System.out.print(getValueofIndex(i)+"->");
		isVisited[i]=true;
		queue.addLast(i);//至此处理完成第一任首长
		//以初始点为开始遍历所有点
		while(!queue.isEmpty()) {
			u=queue.removeFirst();
			w=getfirstNeighbor(u);//下一任候选人
			while(w!=-1) {//还存在邻接点，当w=-1，返回大循环，更换前驱
				//若未被访问
				if(!isVisited[w]) {
				  System.out.print(getValueofIndex(w)+"->");	
				  isVisited[w]=true;
				  queue.addLast(w);//下一任首长
				}
				//访问u的另一邻接点，判断是否被访问
				w=getNextneighbor(u,w);
			}
		}
	}
	//重载bfs
	public void bfs() {
	isVisited=new boolean[vertexList.size()];
	for(int i=0;i<vertexList.size();i++) {
		if(!isVisited[i]) {
			bfs(isVisited,i);
		}
	}
	}
	
	public static void main(String[] args) {
		String vertexs[]= {"A","B","C","D","E"};
		Gragh graph=new Gragh(vertexs.length);
		for(String v:vertexs) {
			graph.insertVertex(v);
		}
		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();
       // graph.dfs();
        graph.bfs();
		
	}
	
}