深度优先遍历代码实现

深度优先遍历

第一次接触深度优先遍历，在这里写出其代码

代码

	public void DFS_real(){
		for(int i = 0;i<getVerter();i++){//这里的getVerter对应的是求解的矩阵的行数目
			if(!isVisited[i]){//刚开始都是从0开始,判断是否被访问，
				DFS_real(isVisited,i);//未被访问则直接进行访问
			}
		}
	}
	private void DFS_real(boolean[] isVisited, int i) {
		System.out.print(getNumofIndex(i)+"->");//打印出数值调用的是下面的函数，得到的节点对应的值
		isVisited[i] = true;//访问过
		//得到下一个邻接矩阵数值
		int w = 0 ;//用w表示下一个邻接矩阵的列的数值
		for(int j = 0;j<verterList.size();j++){
			if(edges[i][j]>0){//edges代表的是图所表示的矩阵
				w = j;
			}
			w = -1;
		}
		while(w != -1){//先判断是否连接存在
			if(!isVisited[w]){//没有被访问
				DFS_real(isVisited,w);
			}
			//被访问了就去寻找下一个邻接矩阵
			for(int j = w+1;j<verterList.size();j++){
				if(edges[i][j] > 0){
					w =  j;
				}
				w= -1;
			}
		}
	}

图的相关属性代码：

//存储定点
	private static ArrayList<String> verterList;
	//存储矩阵
	private static int[][] edges;
	//存储边的树木
	private int numdeges;
	//是否被访问，是为true，否为false
	private static boolean[] isVisited = new boolean[5];//判断是否被访问

初始化图

	//构造器
	public Graph(int n){
		//初始化矩阵
		verterList = new ArrayList<String>(n);
		edges = new int [n][n];
		numdeges = 0;
		
		
	}

相关的操作函数（有需要的，也有不需要的）

//返回节点的个数
	public int getVerter(){
		return verterList.size();
	}
	//边的书目
	public int numdeges(){
		return numdeges;
	}

	//返回节点i对应的值
	public static String getNumofIndex(int i ){
		return verterList.get(i);
	}
	
	//返回v1和v2的权值
	public int getWeight(int v1,int v2){
		return edges[v1][v2];
	}
	
	//显示矩阵
	public void print(){
		for(int[] link : edges){
			System.out.println(Arrays.toString(link));
		}
	}
	
	//插入节点
	public void insertVer(String veString){
		verterList.add(veString);
	}
	//添加边
	public void insertEdges(int v1,int v2,int weight){
		edges[v1][v2] = weight;
		edges[v2][v1] = weight;
		numdeges++;
	}

main函数代码：

public static void main(String[] args) {
		// TODO Auto-generated method stub

		int n = 5;//节点个数
		String vertexString[] ={"A","B","C","D","E"};
		Graph Graph = new Graph(n);
		for(String value : vertexString){
			Graph.insertVer(value);
		}
		//添加边
		
		//a->b,a->c,b->c,b->d,b->e
		Graph.insertEdges(0, 1, 1);
		Graph.insertEdges(0, 2, 1);
		Graph.insertEdges(1, 2, 1);
		Graph.insertEdges(1, 3, 1);
		Graph.insertEdges(1, 4, 1);
		//显示
		Graph.print();
		System.out.println("深度优先遍历结果");
		Graph.DFS_real();
	}

得到的结果为
A-〉B->C->D->E->