深度优先搜索算法及java实现——针对无向无权图

本文链接：https://blog.csdn.net/ASN_forever/article/details/80993836

图是一种比树更宽泛和复杂的数据结构，树只是图的一种特殊形式。

图有很多种划分方式，针对不同的划分方式可以分为连通图/非连通图、有向图/无向图、带权图/非带权图等。

图与树不同，树一般都有固定的结构，如二叉树，一个节点最多有两个子节点，因此可以通过在节点对象中添加两个属性用来存储子节点的引用（类似于边），以此方式实现二叉树。或者是用数组的方式实现数（也就是堆结构）。但是对于图来说，它的邻接顶点的个数是不确定的，因此无法像树那样通过增加邻接顶点的引用之类的方式表示。为了更好的用算法对图进行操作，需要用一种更合适的方式表示图以便计算机能够对其进行操作。

目前一般采用两种方式表示图：①邻接矩阵；②邻接表

（注意：邻接表中的->并不表示路径的意思，其实可以忽略掉它，如第一行，表示的意思是顶点A分别与B、C、D相邻）

对图进行搜索主要有两种方式，一种是深度优先搜索（DFS，通过栈实现），一种是广度优先搜索（BFS，通过队列实现）。

搜索的意思是，从指定顶点出发，找到它能到达的所有顶点。

深度优先搜索算法的思想

在无向图中进行深度优先搜索：首先选定一个顶点作为起始顶点，将起始顶点放入栈首（此时也是栈尾）作为当前顶点，并做标记表示已读，然后寻找一个当前顶点（此时是起始顶点）的邻接顶点，如果存在一个当前顶点的未被标记的邻接顶点，则将此邻接顶点放入栈尾，并把其当做新的当前顶点继续寻找与其相邻接的未被标记的顶点，直到当前顶点不存在邻接顶点或其邻接顶点全被标记为已读，则将当前顶点从栈尾弹出，然后以新的栈尾顶点为当前顶点寻找其未被标记的邻接顶点，如此迭代，直到栈中元素全被弹出时搜索完成。

下面是针对无向无权图的深度优先搜索算法的java实现

public class DFSGraph {
	private int[][] adjMat;
	//private int size;
	private Vertex[] vertexArr;
	private int num;
	private StackGraph sg;
	public static void main(String[] args) {
		DFSGraph g = new DFSGraph(5);
		g.addVertex('A');
		g.addVertex('B');
		g.addVertex('C');
		g.addVertex('D');
		g.addVertex('E');
		g.addVertex('F');
		g.addEdge(0, 1);
		g.addEdge(0, 2);
		g.addEdge(1, 3);
		g.addEdge(2, 3);
		g.addEdge(0, 4);
		g.showGraph();
		System.out.print("visits:");
		g.dfs();
		//System.out.println();
	}
	public DFSGraph(int s){
		//size = s;
		num = 0;
		adjMat = new int[s][s];
		vertexArr = new Vertex[s];
		for(int i=0;i<s;i++){
			for(int j=0;j<s;j++){
				adjMat[i][j] = 0;
			}
		}
		sg = new StackGraph(s);
	}
	public void addVertex(char c){
		if(num<5){
		Vertex nVertex = new Vertex();
		nVertex.setName(c);
		vertexArr[num] = nVertex;
		System.out.println("添加顶点："+c+",所处数组下标为："+num);
		num++;
		}else{
			System.out.println("数组已满！");
		}
	}
	public void addEdge(int from,int to){
		adjMat[from][to] = 1;
		adjMat[to][from] = 1;
	}
	public void showGraph(){
		for(int i=0;i<num;i++){
			for(int j=0;j<num;j++){
				int v = adjMat[i][j];
				System.out.print(v+" ");
			}
			System.out.println();
		}
	}
	public void showVertex(int index){
		System.out.print(vertexArr[index].getName());
	}
	/**
	 * 深度优先搜索算法
	 * 
	 */
	public void dfs(){
		vertexArr[0].wasVisited = true;
		showVertex(0);
		sg.push(0);
		while(!sg.isEmpty()){
			int v = getAdjUnvisitedVertex(sg.peek());
			if(v==-1){
				sg.pop();//当当前节点找不到未被访问的临近节点时，将其从栈顶弹出
			}else{
				vertexArr[v].wasVisited = true;
				showVertex(v);
				sg.push(v);
			}
		}
		for(int j=0;j<num;j++){
			vertexArr[j].wasVisited = false;
		}
	}
	/**
	 * 此方法根据传入的值查找对应的节点是否有未被访问过的临近节点，如果有，则将找到的第一个符合条件的临近节点的下标返回
	 * 否则返回-1
	 * @param v
	 * @return
	 */
	public int getAdjUnvisitedVertex(int v){
		for(int i=0;i<num;i++){
			if(adjMat[v][i]==1&&vertexArr[i].wasVisited==false){
				return i;//找到一个就返回
			}
		}
		return -1;
	}
}

class Vertex{
	private char name;
	private int index;
	public boolean wasVisited;
	public Vertex(){
		wasVisited = false;
	}
	public void setName(char c){
		this.name = c;
	}
	public char getName(){
		return this.name;
	}
	public boolean wasVisited(){
		return this.wasVisited;
	}	
}
class StackGraph{
	private int[] st;
	private int top;
	public StackGraph(int size){
		st = new int[size];
		top = -1;
	}
	public void push(int j){
		st[++top] = j;
	}
	public int pop(){
		return st[top--];
	}
	public int peek(){
		return st[top];
	}
	public boolean isEmpty(){
		return top == -1;
	}
}

运行结果为：

下面的代码是第二天自己独立写的，虽然不够好，很粗糙，但写一遍的过程让自己对dfs理解更深了。

/**
 * 在使用邻接矩阵来表示图的情况下，深度优先搜索使用栈来实现！
 * 程序结构：
 * 	①首先应该有个顶点类用于生成顶点对象，里面应该包括一些属性，比如顶点数据项、用于检查是否被读的标记
 * 	②然后应该有个图类，这个图类能够在构造器中生成邻接矩阵，并包含一些方法，比如生成顶点，设置边，最重要的是有dfs算法
 * 	③其次应该有个栈类，用于在执行dfs算法时，将相应访问的顶点压入栈和弹出栈
 * 	④最后应该有个主类用于测试
 * @author ht
 *
 */


//主类
public class DFSGraph {
	public static void main(String[] args) {
		Graph g = new Graph(5);
		g.generateVertex('A');
		g.generateVertex('B');
		g.generateVertex('C');
		g.generateVertex('D');
		g.generateVertex('E');
		g.generateVertex('F');
		g.showAdjMatrix();
		g.generateEdge(0, 1);
		g.generateEdge(0, 2);
		g.generateEdge(1, 3);
		g.generateEdge(2, 3);
		g.generateEdge(0, 4);
		g.showAdjMatrix();
		g.dfs();
	}
}


//顶点类
class Vertex{
	//数据项
	private char elem;
	public boolean isRead;
	public Vertex(char e){
		this.elem = e;
		isRead = false;
	}
	public char getElem(){
		return this.elem;
	}
	
}


//图类
class Graph{
	private int graphSize;
	private int[][] adjMatrix;
	private Vertex newVertex;
	private int countVertex;
	private Vertex[] vertexArr;
	private VertexStack vs;
	//构造器，根据传入的参数初始化一个指定大小的邻接矩阵，并将矩阵中的元素全部设为0
	public Graph(int size){
		graphSize = size;
		countVertex = 0;
		vertexArr = new Vertex[size];
		adjMatrix = new int[size][size];
		vs = new VertexStack(size);
		for(int i=0;i<graphSize;i++){
			for(int j=0;j<graphSize;j++){
				adjMatrix[i][j] = 0;
			}
		}
	}
	
	//生成新顶点，并将顶点对象插入数组中
	public void generateVertex(char vertex_elem){
		if(countVertex<graphSize){
		newVertex = new Vertex(vertex_elem);
		vertexArr[countVertex] = newVertex;
		countVertex++;
		System.out.println("生成新顶点："+newVertex.getElem());
		}else{
			System.out.println("顶点个数已超出范围！无法生成新顶点："+vertex_elem);
		}
	}
	
	//设置邻接顶点，也就是生成边
	public void generateEdge(int from,int to){
		adjMatrix[from][to] = 1;
		adjMatrix[to][from] = 1;
	}
	
	//显示邻接矩阵
	public void showAdjMatrix(){
		System.out.println("当前邻接矩阵显示如下：");
		for(int i=0;i<graphSize;i++){
			for(int j=0;j<graphSize;j++){
				System.out.print(adjMatrix[i][j]+" ");
			}
			System.out.println();
		}
	}
	
	//dfs算法，这是最重要的部分，需要跟栈配合使用。
	public void dfs(){
		int index = 0;
		vs.push(vertexArr[0].getElem());
		System.out.print("深度优先搜索结果为：");
		vs.showStack(vertexArr[0].getElem());
		vertexArr[0].isRead = true;
		int i = 0;
		while(vs.cursor!=-1){
		//for(int i=0;i<graphSize;i++){
			for(int j=0;j<graphSize;j++){
				if(adjMatrix[i][j] == 1 && vertexArr[j].isRead == false){
					vs.push(vertexArr[j].getElem());
					vs.showStack(vertexArr[j].getElem());
					vertexArr[j].isRead = true;
					index = j;
					break;
				}
			}
			if(index == 0){
				index = vs.pop()-1;
			}
		  i = index;
		  index = 0;
		//}
	  }
	}
}
//用来存储dfs过程中遍历的顶点
class VertexStack{
	private char[] size;
	public int cursor;
	public VertexStack(int stackSize){
		size = new char[stackSize];
		cursor = -1;
	}
	public void push(char elem){
		size[++cursor] = elem;
	}
	public int pop(){
		return cursor--;
	}
	public void showStack(char e){
		System.out.print(e);
	}
}	①首先应该有个顶点类用于生成顶点对象，里面应该包括一些属性，比如顶点数据项、用于检查是否被读的标记
 * 	②然后应该有个图类，这个图类能够在构造器中生成邻接矩阵，并包含一些方法，比如生成顶点，设置边，最重要的是有dfs算法
 * 	③其次应该有个栈类，用于在执行dfs算法时，将相应访问的顶点压入栈和弹出栈
 * 	④最后应该有个主类用于测试
 * @author ht
 *
 */


//主类
public class DFSGraph {
	public static void main(String[] args) {
		Graph g = new Graph(5);
		g.generateVertex('A');
		g.generateVertex('B');
		g.generateVertex('C');
		g.generateVertex('D');
		g.generateVertex('E');
		g.generateVertex('F');
		g.showAdjMatrix();
		g.generateEdge(0, 1);
		g.generateEdge(0, 2);
		g.generateEdge(1, 3);
		g.generateEdge(2, 3);
		g.generateEdge(0, 4);
		g.showAdjMatrix();
		g.dfs();
	}
}


//顶点类
class Vertex{
	//数据项
	private char elem;
	public boolean isRead;
	public Vertex(char e){
		this.elem = e;
		isRead = false;
	}
	public char getElem(){
		return this.elem;
	}
	
}


//图类
class Graph{
	private int graphSize;
	private int[][] adjMatrix;
	private Vertex newVertex;
	private int countVertex;
	private Vertex[] vertexArr;
	private VertexStack vs;
	//构造器，根据传入的参数初始化一个指定大小的邻接矩阵，并将矩阵中的元素全部设为0
	public Graph(int size){
		graphSize = size;
		countVertex = 0;
		vertexArr = new Vertex[size];
		adjMatrix = new int[size][size];
		vs = new VertexStack(size);
		for(int i=0;i<graphSize;i++){
			for(int j=0;j<graphSize;j++){
				adjMatrix[i][j] = 0;
			}
		}
	}
	
	//生成新顶点，并将顶点对象插入数组中
	public void generateVertex(char vertex_elem){
		if(countVertex<graphSize){
		newVertex = new Vertex(vertex_elem);
		vertexArr[countVertex] = newVertex;
		countVertex++;
		System.out.println("生成新顶点："+newVertex.getElem());
		}else{
			System.out.println("顶点个数已超出范围！无法生成新顶点："+vertex_elem);
		}
	}
	
	//设置邻接顶点，也就是生成边
	public void generateEdge(int from,int to){
		adjMatrix[from][to] = 1;
		adjMatrix[to][from] = 1;
	}
	
	//显示邻接矩阵
	public void showAdjMatrix(){
		System.out.println("当前邻接矩阵显示如下：");
		for(int i=0;i<graphSize;i++){
			for(int j=0;j<graphSize;j++){
				System.out.print(adjMatrix[i][j]+" ");
			}
			System.out.println();
		}
	}
	
	//dfs算法，这是最重要的部分，需要跟栈配合使用。
	public void dfs(){
		int index = 0;
		vs.push(vertexArr[0].getElem());
		System.out.print("深度优先搜索结果为：");
		vs.showStack(vertexArr[0].getElem());
		vertexArr[0].isRead = true;
		int i = 0;
		while(vs.cursor!=-1){
		//for(int i=0;i<graphSize;i++){
			for(int j=0;j<graphSize;j++){
				if(adjMatrix[i][j] == 1 && vertexArr[j].isRead == false){
					vs.push(vertexArr[j].getElem());
					vs.showStack(vertexArr[j].getElem());
					vertexArr[j].isRead = true;
					index = j;
					break;
				}
			}
			if(index == 0){
				index = vs.pop()-1;
			}
		  i = index;
		  index = 0;
		//}
	  }
	}
}
//用来存储dfs过程中遍历的顶点
class VertexStack{
	private char[] size;
	public int cursor;
	public VertexStack(int stackSize){
		size = new char[stackSize];
		cursor = -1;
	}
	public void push(char elem){
		size[++cursor] = elem;
	}
	public int pop(){
		return cursor--;
	}
	public void showStack(char e){
		System.out.print(e);
	}
}

运行结果：