Java数据结构——图的总结

一、图的应用

（一）、MGraph

package graph;

/**
 * 接口
 * 通过邻接矩阵来构造
 */
interface IGraph {
   

	/**
	 * 得到顶点的数目
	 * 
	 * @return
	 */
	public int getVexNum();

	/**
	 * 得到边的数目
	 * 
	 * @return
	 */
	public int getArcNum();

	/**
	 * 定位顶点的位置
	 * 
	 * @param data
	 * @return
	 */
	public int indexOfVex(String data);

	/**
	 * 定位指定位置的顶点
	 * 
	 * @param index
	 * @return
	 */
	public String valueOfVex(int index);

	/**
	 * 打印邻接矩阵
	 */
	public void printMGraph();

} // IGraph

/**
 * @MatrixGraph 邻接矩阵
 * 
 * @author 己千之
 * @time 2022/2/20
 */
public class MGraph implements IGraph {
   

	/**
	 * @INF 无穷大 private static final int INF=Integer.MAX_VALUE; @1.
	 *      因为有时侯要打印邻接矩阵，太大了不好看 @2. 因为最小生成数涉及到网
	 */
	public static final int INF = 999; // 最大值

	/**
	 * 存储图的顶点的一维数组
	 */
	public String[] vexs;

	/**
	 * @邻接矩阵 存储图的边的二维数组
	 */
	public int[][] arcs;

	/**
	 * 顶点的实际数量
	 */
	public int vexNum;

	/**
	 * 边数
	 */
	public int arcNum;

	/**
	 * 构造函数
	 */
	public MGraph(String[] vertexs, int[][] adjMatrix) {
   

		// 1. 初始成员变量
		int num = vertexs.length;
		int row = adjMatrix.length;
		int col = adjMatrix[0].length;
		if (row != col && row != num) {
   
			throw new RuntimeException("row != col,邻接矩阵有误!");
		}
		vexNum = num;
		vexs = new String[vexNum];
		arcs = new int[vexNum][vexNum];

		// 1.1 初始化值
		for (int i = 0; i < vexNum; i++) {
   
			vexs[i] = vertexs[i];
		}
		for (int i = 0; i < vexNum; i++) {
   
			for (int j = 0; j < vexNum; j++) {
   
				arcs[i][j] = adjMatrix[i][j];
			}
		}

		// 1.2 设置边数
		for (int i = 0; i < vexNum; i++) {
   
			for (int j = 0; j < vexNum; j++) {
   
				if (arcs[i][j] != 0 && arcs[i][j] != INF) {
   
					arcNum++;
				}
			}
		}

	}

	@Override
	public int getVexNum() {
   
		return this.vexNum;
	}

	@Override
	public int getArcNum() {
   
		return this.arcNum;
	}

	@Override
	public int indexOfVex(String data) {
   
		for (int i = 0; i < vexNum; i++) {
   
			if (vexs[i] == data)
				return i;
		}
		return -1;
	}

	@Override
	public String valueOfVex(int index) {
   
		if (index < 0 || index >= vexNum) {
   
			throw new RuntimeException("位置错误!");
		}
		return vexs[index];
	}

	@Override
	public void printMGraph() {
   
		System.out.println("邻接矩阵:");
		int t = 0; // 格式控制
		for (int i = 0; i < arcs.length; i++) {
   
			for (int j = 0; j < arcs.length; j++) {
   
				System.out.printf("%4d", arcs[i][j]);
				t++;
				if (t % arcs.length == 0) {
   
					System.out.println();
				}
			}
		}
	} // printMGraph

} // MGraph

（二）、GraphApp

package graph;

/**
 * 为了使用队列，而导入
 * 广度优先遍历
 */
import java.util.LinkedList;

/**
 * @ 图的应用
 * 
 * @ 1. 用的是MGraph，邻接矩阵。 
 * @ 2. MGraph代码在 邻接矩阵那一天 
 * @ 3. 图的应用，我会打很多注释，其实代码不多。
 * 
 * @author 己千之
 * @time 2022/2/18
 */
public class GraphApp extends MGraph {
   

	public GraphApp(String[] vertexs, int[][] adjMatrix) {
   
		super(vertexs, adjMatrix);
	}

	// *****************************图的遍历********************************************//
	// TODO 图的遍历

	/**
	 * 辅助数组，便于顶点只访问一次
	 */
	boolean[] visited;

	/**
	 * 得到与这个顶点相邻的第一个顶点的位置
	 * 
	 * @ 1. vexNum 在MGraph里面 @ 2. arcs 在MGraph里面, 相当于邻接矩阵
	 * 
	 * @param v 顶点的位置
	 * @return
	 */
	public int indexOfFirstNeighbor(int v) {
   
		for (int i = 0; i < vexNum; i++) {
   
			if (arcs[v][i] > 0) {
   
				return i;
			}
		}
		return -1;
	}

	/**
	 * 得到与这个顶点相邻的下一个顶点的位置
	 * 
	 * @ 1. 就是相邻的 下一个 @ 2. 看【i = v2 + 1】把相邻的那个跳过了
	 * 
	 * @param v1
	 * @param v2
	 * @return
	 */
	public int indexOfNextNeighbor(int v1, int v2) {
   
		for (int i = v2 + 1; i < vexNum; i++) {
   
			if (arcs[v1][i] > 0) {
   
				return i;
			}
		}
		return -1;
	}

	/**
	 * DFS
	 * 
	 * @ 1. valueOfVex函数，在MGraph里面 
	 * @ 2. 方法：递归 
	 * @ 3. private 这个函数只能在当前类使用，避免混乱
	 * 
	 * @param isVisited 是形参
	 * @param v
	 */
	private void DFSTraverse(boolean[] isVisited, int v) {
   
		System.out.print(valueOfVex(v) + "->");
		visited[v] = true;

		int w = indexOfFirstNeighbor(v);
		while (w != -1) {
   
			if (!visited[w]) {
   
				DFSTraverse(visited, w);
			}
			w = indexOfNextNeighbor(v, w);
		}
	}

	/**
	 * DFSTraverse
	 * 
	 * @ 1. DFSTraverse()方法的重载 
	 * @ 2. DFSTraverse()方法对父类MGraph重写 
	 * @ 3. Override 是否在父类中
	 */
	public void DFSTraverse() {
   
		System.out.println("深度优先搜索遍历：");

		// 关键代码
		visited = new boolean[vexNum];
		for (int i = 0; i < vexNum; i++) {
   
			if (!visited[i]) {
   
				DFSTraverse(visited, i);
			}
		}

		System.out.print("NULL");
	}

	/**
	 * BFS
	 * 
	 * @ 1. private 这个函数只能在当前类使用，避免混乱 @ 2. 方法：队列
	 * 
	 * @param isVisited
	 * @param v
	 */
	private void BFSTraverse(boolean[] isVisited, int v) {
   
		int u;
		int w;
		LinkedList<Integer> queue = new LinkedList<Integer>();
		System.out.print(valueOfVex(v) + "->");
		visited[v] = true;
		queue.addLast(v); // 入队

		while (!queue.isEmpty()) {
   
			u = (Integer) queue.removeFirst(); // 出队
			w = indexOfFirstNeighbor(u);
			while (w != -1) {
   
				if (!visited[w]) {
   
					System.out.print(valueOfVex(w) + "->");
					visited[w] = true;
					queue.addLast(w);
				}
				w