不带权图：基于深度优先搜索实现的最小生成树——java实现

深度优先搜索参考：https://blog.youkuaiyun.com/ASN_forever/article/details/80993836

最小生成树

用最少数量的边来实现图中各顶点之间的连通，也就是用最少数量的边实现连通图，则这些边就组成了一个最小生成树。

同一个图，通常有很多个最小生成树。

最小生成树边的数量永远都比顶点的数量少1。

下面是基于深度优先搜索实现的最小生成树java代码，针对的是不带权图

/**
 * 在使用邻接矩阵来表示图的情况下，深度优先搜索使用栈来实现！
 * 程序结构：
 * 	①首先应该有个顶点类用于生成顶点对象，里面应该包括一些属性，比如顶点数据项、用于检查是否被读的标记
 * 	②然后应该有个图类，这个图类能够在构造器中生成邻接矩阵，并包含一些方法，比如生成顶点，设置边，最重要的是有dfs算法
 * 	③其次应该有个栈类，用于在执行dfs算法时，将相应访问的顶点压入栈和弹出栈
 * 	④最后应该有个主类用于测试
 * 
 * 	⑤作为扩展，在Graph类中增加了mst()方法用来生成最小生成树。mst()与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(0, 3);
		g.generateEdge(0, 4);
		g.generateEdge(1, 2);
		g.generateEdge(1, 3);
		g.generateEdge(1, 4);
		g.generateEdge(2, 3);
		g.generateEdge(2, 4);
		g.generateEdge(3, 4);
		g.showAdjMatrix();
		g.dfs();
		g.mst();
	}
}

//顶点类
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;
		//}
	  }
		for(int i1=0;i1<graphSize;i1++){
			vertexArr[i1].isRead = false;
		}
		System.out.println();
	}
	
	//最小生成树方法
	public void mst(){
		int index = 0;
		vs.push(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){
					System.out.println("邻接顶点："+vs.size[vs.cursor]+vertexArr[j].getElem());
					vs.push(vertexArr[j].getElem());
					vertexArr[j].isRead = true;
					index = j;
					break;
				}
			}
			if(index == 0){
				index = vs.pop()-1;
			}
		  i = index;
		  index = 0;
		//}
	  }
	}
}
//用来存储dfs过程中遍历的顶点
class VertexStack{
	public 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);
	}
}

运行结果：