一.什么是图?有哪些特性及其使用场景?
由来: 当我们需要表示多对多的关系的时候,就需要使用到图这种数据结构
定义: 图是一种数据结构,其中顶点可以是具有零个或多个相邻元素.两个顶点之间的连线称为边,节点被称为顶点
常用概念: 无向图表示顶点之间的连接没有方向,既可以A->B,也可以B->A,有向图表示顶点之间的连接有方向,A->B,B->A,表示不同的路径
图的创建: 邻接矩阵(使用二维数组)和邻接表(使用链表)
public class Graph { private List<String> vertexList; // 存储顶点的集合 private int[][] edges; // 存储图对应的邻接矩阵 private int numberOfEdges; // 表示边的数量 private boolean[] isVisited; // 是否被访问过 public static void main(String[] args) { Graph graph = new Graph(5); String[] vertexes = {"A","B","C","D","E"}; // 添加节点 for (String vertex : vertexes) { graph.insertVertex(vertex); } // 添加边 A-B A-C B-C B-D B-E 用于创建邻接矩阵 graph.insertWeight(0,1,1); graph.insertWeight(0,2,1); graph.insertWeight(1,2,1); graph.insertWeight(1,3,1); graph.insertWeight(1,4,1); graph.showGraph(); } /** * 构造器 ,初始化顶点,邻接矩阵,边的数目,是否访问过 * @param n */ public Graph(int n) { vertexList = new ArrayList<String> (n); edges = new int[n][n]; isVisited = new boolean[n]; numberOfEdges = 0; } }
/** * 插入顶点 * @param vertex */ public void insertVertex(String vertex){ vertexList.add(vertex); } /** * 添加边 无向图 * @param v1 表示第一个顶点对应的下标 * @param v2 表示第二个顶点对应的下标 * @param weight 表示权值 */ public void insertWeight(int v1,int v2,int weight){ edges[v1][v2] = weight; edges[v2][v1] = weight; numberOfEdges++; }
执行结果:
二.图的遍历
深度优先遍历(dfs)
基本思想:
1.从初始访问的节点出发,初始访问的节点可能有多个邻接节点,深度优先遍历的策略是首先访问第一个邻接节点,然后在把这个被访问过的邻接节点
作为初始节点,在访问它的邻接节点.即每次访问完当前节点后首先访问当前节点的第一个邻接节点
2.这样的访问策略是优先纵向的挖掘深入,而不是对所有的节点进行横向的访问
3.这是一个递归调用的过程
步骤:
1.访问初始节点v,并将v标记为已访问
2.查找节点v的第一个邻接节点w
3.若w存在,继续执行4,如果不存在,回到第1步,继续从v的下一个节点继续
4.若w未被访问,对w进行深度优先访问
5.查找节点v的w邻接节点的下一个邻接节点,转到步骤3
/** * 返回节点i对应的数据 * @param i * @return */ public String getValueByIndex(int i){ return vertexList.get(i); } /** * 找到第一个相邻节点的下标 * @param index * @return */ public int getFirstNeighbor(int index){ for (int j = 0; j < vertexList.size(); j++) { if (edges[index][j] != 0){ return j; } } return -1; } /** * 根据前一个相邻节点的下标获取下一个相邻节点的下标 * @param v1 * @param v2 * @return */ 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; } /** * 深度优先遍历 * @param isVisited * @param i */ private void dfs(boolean[] isVisited,int i){ // 访问当前的节点 System.out.print(getValueByIndex(i) +"->"); // 将被访问的节点设置成已访问 isVisited[i] = true; // 获取当前节点的相邻的节点 int w = getFirstNeighbor(i); while (w != -1){ // 只要当前节点的邻接点不为空 if (!isVisited[w]){ // 如果没有访问过 dfs(isVisited, w); //继续递归 } // 继续从它的下一个邻接点开始执行 w = getNextNeighbor(i,w); } } public void dfs(){ isVisited = new boolean[vertexList.size()]; for (int i = 0; i < vertexList.size(); i++) { if (!isVisited[i]) { dfs(isVisited, i); } } }
执行结果:
广度优先遍历(bfs)
基本思想:
类似于分层搜索的过程,需要使用一个队列来保存访问过的节点顺序,以便按照这个顺序来访问这些节点的邻接节点
步骤:
1.访问初始节点v,并将v标记为已访问
2.节点v入队列
3.当队列非空时,继续执行,否则算法结束
4.出队列,取出队列头u
5.查找u的第一个邻接节点w
6.若节点u的的邻接节点w不存在,转回步骤3,否则执行步骤7
7.若节点w尚未被访问,则将w标记为已访问
8.节点w入队列
9.查找节点u的继w的邻接节点后的下一个邻接节点,重复步骤6直到队列为空
/** * 广度优先遍历 * @param isVisited * @param i */ private void bfs(boolean[] isVisited, int i){ int u; // 表示队列头结点对应的下标 int w; // 邻接节点w // 用于记录节点访问的顺序 Queue<Integer> queue = new LinkedList<>(); // 访问节点,输出节点的值 System.out.print(getValueByIndex(i) + "->"); // 将已访问的节点标记为已访问 isVisited[i] = true; // 将已访问的节点加入到队列 queue.add(i); while (!queue.isEmpty()){ // 取出队列头节点的下标 u = queue.remove(); // 得到其邻接节点的下标 w = getFirstNeighbor(u); while (w != -1){ // 如果邻接节点存在 if(!isVisited[w]){ // 是否已经访问过该节点 System.out.print(getValueByIndex(w) + "->"); // 访问该节点 isVisited[w] = true; // 将该节点的状态设置为已访问 queue.add(w); // 加入到队列中 } w = getNextNeighbor(u,w); //以u为前驱节点,找到其下一个节点 } } } public void bfs(){ isVisited = new boolean[vertexList.size()]; for (int i = 0; i < vertexList.size(); i++) { if (!isVisited[i]) { bfs(isVisited,i); } } }
执行结果:
三.求解图的最小生成树
什么是最小生成树?
1.给定一个带权的无向连通图,如何选取一颗生成树,使得树上所有边上权的总和为最小,就叫最小生成树
2.有N个顶点,一定会有N-1条边,并且包含全部的顶点
如何求得最小生成树
1.普里姆算法
步骤:
1.设G=(V,E)是联通网,T=(U,D)是最小生成树,V,U是顶点集合,E,D是边的集合
2.若从顶点u开始构建最小生成树,则从集合V中取出顶点u放入到集合U中,并标记顶点v为已访问
3.若集合U中的顶点ui和集合U-V的顶点vj之间存在边,则寻找这些边权值的最小边,但不能构成回路,将顶点vj加入集合U中,标记顶点v已访问
4.重复步骤2,直到集合V和U相等,并且所有的顶点都标记为已访问,此时D中就有n-1条边
创建图对象并初始化
class MGraph{ int vertexes; // 图的节点个数 char[] data; // 存放顶点坐标 int[][] weight;// 存放边,即邻接矩阵 public MGraph(int vertexes) { this.vertexes = vertexes; data = new char[vertexes]; weight = new int[vertexes][vertexes]; } }
class MinTree { /** * 创建图对象 * @param graph * @param vertexes * @param data * @param weight */ public void createGraph(MGraph graph,int vertexes,char[] data,int[][] weight){ for (int i = 0; i < vertexes; i++) { graph.data[i] = data[i]; for (int j = 0; j < vertexes; j++){ graph.weight[i][j] = weight[i][j]; } } } /** * 显示图的邻接矩阵 * @param graph */ public void show(MGraph graph){ for(int[] link:graph.weight){ System.out.println(Arrays.toString(link)); } } }
public static void main(String[] args) { char[] data = {'A','B','C','D','E','F','G'}; int vertexes = data.length; // 使用10000表示两条线之间不连通 int[][] weight = { {10000,5,7,10000,10000,10000,2}, {5,10000,10000,9,10000,10000,3}, {7,10000,10000,10000,8,10000,10000}, {10000,9,10000,10000,10000,4,10000}, {10000,10000,8,10000,10000,5,4}, {10000,10000,10000,4,5,10000,6}, {2,3,10000,10000,4,6,10000},}; MinTree minTree = new MinTree(); MGraph graph = new MGraph(vertexes); minTree.createGraph(graph,vertexes,data,weight); minTree.show(graph); }
}
执行结果:
实现普利姆算法,假设从G点开始走
/** * 普利姆算法 * @param graph 图对象 * @param v 从哪个顶点开始 */ public void prim(MGraph graph,int v){ // 存放访问过的节点 int[] visited = new int[graph.vertexes]; //初始化visited的值 for (int i = 0; i < graph.vertexes;i++){ visited[i] = 0; } // 把当前的节点标记为已访问 visited[v] = 1; // h1和h2 记录两个顶点的下标 int h1 = -1; int h2 = -1; // 把minWeight设置为一个最大值,表示两个点不能连通,后续会替换 int minWeight = 10000; for (int k = 1; k < graph.vertexes;k++){ // 因为有vertexes个顶点,所以结束后,会生成vertexes-1条边,边的数量 for (int i = 0; i < graph.vertexes;i++){ // i表示已经访问过的节点 for (int j = 0; j < graph.vertexes;j++){// j表示未访问过的节点 if (visited[i] == 1 && visited[j] == 0 && graph.weight[i][j] < minWeight){ // 寻找已访问的节点和未访问过的节点间的权值最小的边 minWeight = graph.weight[i][j]; // 将minWeight的值更新为图的权重值 h1 = i; // h1更新为已访问 h2 = j; // h2更新为已访问 } } } System.out.println("<" + graph.data[h1] + ", "+graph.data[h2] + "> 权值:"+ minWeight); // 把当前的节点设置为已访问 visited[h2] = 1; // 重置minWeight的值 minWeight = 10000; } }
执行结果:
2.克鲁斯卡尔算法
步骤:
1.按照权值从到到小进行排序
2.保证这些边不构成回路
1.创建图
public class KruskalDemo { private int edgeNums; // 边的数量 private char[] vertexes; // 顶点的集合 private int[][] matrix; // 邻接矩阵 private static final int INF = Integer.MAX_VALUE;// 表示两点之间不能联通 public static void main(String[] args) { char[] vertexes = {'A','B','C','D','E','F','G'}; int matrix[][] = { /*A*//*B*//*C*//*D*//*E*//*F*//*G*/ /*A*/ { 0, 12, INF, INF, INF, 16, 14}, /*B*/ { 12, 0, 10, INF, INF, 7, INF}, /*C*/ { INF, 10, 0, 3, 5, 6, INF}, /*D*/ { INF, INF, 3, 0, 4, INF, INF}, /*E*/ { INF, INF, 5, 4, 0, 2, 8}, /*F*/ { 16, 7, 6, INF, 2, 0, 9}, /*G*/ { 14, INF, INF, INF, 8, 9, 0}}; KruskalDemo kruskal = new KruskalDemo(vertexes,matrix); kruskal.show(); } /*初始化顶点和邻接矩阵*/ public KruskalDemo(char[] vertexes,int[][] matrix){ // 构造方法 int vlen = vertexes.length; //使用复制拷贝的方法初始化顶点 this.vertexes = new char[vlen]; for (int i = 0; i < vertexes.length; i++){ this.vertexes[i] = vertexes[i]; } // 使用复制拷贝的方法,初始化边(权值) this.matrix = new int[vlen][vlen]; for (int i = 0; i < vertexes.length; i++){ for (int j = 0; j < vertexes.length; j++){ this.matrix[i][j] = matrix[i][j]; } } // 初始化有效边的数量 for (int i = 0; i < vertexes.length; i++){ // 自己和自己不算有效边 for (int j = i+1; j < vertexes.length; j++){ if (this.matrix[i][j] != INF){ edgeNums++; } } } } public void show(){ for (int i = 0; i < vertexes.length;i++){ for (int j = 0; j < vertexes.length; j++){ System.out.printf("%d ",matrix[i][j]); } System.out.println(); } } }
执行结果:
创建边,根据权值进行升序排列
class Edata implements Comparable<Edata>{ public char start; // 边的起始点 public char end; // 边的终点 public int weight; // 边的权值 public Edata(char start, char end, int weight) { this.start = start; this.end = end; this.weight = weight; } @Override public String toString() { return "Edata [<" + start +","+end+">= "+weight+"]"; } @Override public int compareTo(Edata o) { // 升序排列 return this.weight - o.weight; } }
判断两条边是否是同一个终点,如果不是就加入到树中,直到树扩大成一个森林
/** * 返回一个顶点对应的下标值,找不到返回-1 * @param ch * @return */ private int getPosition(char ch){ for (int i = 0; i < vertexes.length;i++){ if (vertexes[i] == ch ){ return i; } } return - 1; } /** * 获取图中的边,放入到Edata数组中, * @return */ private Edata[] getEdges(){ int index = 0; Edata[] edges = new Edata[edgeNums]; for (int i = 0; i < vertexes.length;i++){ for (int j = i+1; j < vertexes.length; j++) { if (matrix[i][j] != INF){ edges[index++] = new Edata(vertexes[i],vertexes[j],matrix[i][j]); } } } return edges; } /** * 获取下标为i顶点对应的终点,用于判断两个顶点的终点是否相同 * @param ends 记录了各个顶点对应的终点是哪个,在遍历过程中,逐步形成 * @param i 传入的顶点对应的下标 * @return 返回这个顶点的终点对应的下标 */ private int getEnd(int[] ends,int i){ while (ends[i] != 0){ i = ends[i]; } return i; }
完成算法
public void kruskal(){ int index = 0; // 表示最后结果的数组索引 int[] ends = new int[edgeNums]; // 用于保存已有最小生成树中每个顶点的终点 Edata[] rets = new Edata[edgeNums]; // 创建结果数组,保留最后的最小生成树 Edata[] edges = getEdges(); // 获取所有边的集合 Collections.sort(Arrays.asList(edges)); // 排序 // System.out.println("图的边的集合=" + Arrays.toString(edges) + " 共"+ edges.length); // 将边添加到最小生成树中,同时判断是否生成回路 for (int i = 0; i < edgeNums; i++){ // 获取第i条边的第一个顶点 int p1 = getPosition(edges[i].start); // 获取第i条边的第二个顶点 int p2 = getPosition(edges[i].end); // 获取p1这个顶点在已有最小生成树中的终点 int m = getEnd(ends,p1); // 获取p2这个顶点在已有最小生成树中的终点 int n = getEnd(ends,p2); // 是否构成回路 if (m != n){ // 如果没有构成回路 ends[m] = n; // 设置m在已有最小生成树中的终点 rets[index++] = edges[i]; // 将这条边加入到结果数组 } } System.out.println("最小生成树为:"); for (int i = 0; i < index; i++){ System.out.println(rets[i]); } }
执行结果:
四.求出图的最短路径
1.迪杰斯特拉算法(从单一顶点出发到其他的各个顶点的最小路径)
步骤:
1.设出发顶点为v,顶点集合V{v1,v2,...vi},v到V中各顶点集合的距离集合Dis,Dis{d1,d2,...di},Dis记录了v到图中各个顶点的距离(到自身可以看做是0,v到vi对应的距离是di)
2.从Dis中选择值最小的di并移出Dis集合,同时移除V集合对应的顶点vi,此时的v到vi即为最短路径
3.更新Dis集合,比较v到V集合中顶点的距离值,与v通过vi到V集合中顶点的距离值,保留较小的那个(同时也应该更新顶点的前驱节点为vi,表示通过vi达到的)
4.重复步骤2和3,直到最短路径顶点为目标顶点即可结束
初始化图
public static void main(String[] args) { char[] vertexes = {'A','B','C','D','E','F','G'}; int[][] matrix = new int[vertexes.length][vertexes.length]; final int N = 65535;// 表示不可以连接 matrix[0]=new int[]{N,5,7,N,N,N,2}; matrix[1]=new int[]{5,N,N,9,N,N,3}; matrix[2]=new int[]{7,N,N,N,8,N,N}; matrix[3]=new int[]{N,9,N,N,N,4,N}; matrix[4]=new int[]{N,N,8,N,N,5,4}; matrix[5]=new int[]{N,N,N,4,5,N,6}; matrix[6]=new int[]{2,3,N,N,4,6,N}; Graph g = new Graph(vertexes,matrix); g.showGraph(); } class Graph { public char[] vertexes; public int[][] matrix; public VisitedVertex vv; public Graph(char[] vertexes, int[][] matrix) { this.vertexes = vertexes; this.matrix = matrix; } public void showGraph(){ for (int[] links:matrix){ System.out.println(Arrays.toString(links)); } } }
执行结果:
初始化前驱节点,已访问节点和距离
class VisitedVertex { /*记录各个顶点是否访问过,1表示已访问,0表示未访问*/ public int[] already_arr; /*记录每一个下标对应值的前一个下标,动态更新*/ public int[] pre_visited; /*记录出发顶点到各个顶点的距离*/ public int[] dis; /** * * @param length 初始化顶点的个数 * @param index 从哪个顶点开始 */ public VisitedVertex(int length,int index) { already_arr = new int[length]; pre_visited = new int[length]; dis = new int[length]; /*初始化dis数组*/ Arrays.fill(dis,65535); /*设置除法顶点被访问过*/ this.already_arr[index] = 1; /*设置出发顶点的访问距离为0*/ this.dis[index] = 0; } /** * 判断某各顶点是否被访问过 * @param index * @return */ public boolean in(int index){ return already_arr[index] == 1; } /** * 更新出发顶点到index节点的距离 * @param index * @param len */ public void updateDis(int index,int len){ dis[index] = len; } /** * 更新pre这个顶点的前驱节点为index顶点 * @param pre * @param index */ public void updatePre(int pre,int index){ pre_visited[pre] = index; } /** * 返回出发顶点到index的距离 * @param index * @return */ public int getDis(int index){ return dis[index]; } /** * 继续选择并返回新的访问节点 * @return */ public int updateArr(){ int min = 65535; int index = 0; for (int i = 0; i < already_arr.length;i++){ if (already_arr[i] == 0 && dis[i] < min){ //使用广度优先的策略,如果初始节点的下一个没有被访问,并且可以连通,就选择下一个节点为出发节点 min = dis[i]; index = i; } } /*更新index顶点被访问过*/ already_arr[index] = 1; return index; } }
更新周围顶点和前驱节点的距离,完成算法
public void djs(int index){ vv = new VisitedVertex(vertexes.length,index); /*更新index顶点到周围顶点的距离和前驱节点*/ update(index); for (int j = 1; j < vertexes.length; j++) { /*选择并返回新的访问节点*/ index = vv.updateArr(); /*更新index顶点到周围顶点的距离和前驱节点*/ update(index); } } /** * 更新index下标顶点周围顶点的距离和周围顶点的前驱节点 * @param index */ public void update(int index){ int len = 0; /*遍历邻接矩阵的matrix[index]所对应的行*/ for (int i = 0; i < matrix[index].length; i++) { /*出发顶点到index顶点的距离 + 从index到i顶点的距离和*/ len = vv.getDis(index) + matrix[index][i]; /*如果i顶点没有被访问过,并且len小于出发顶点到j顶点的距离,就需要更新*/ if (!vv.in(i) && len < vv.getDis(i)){ /*更新i点的前驱节点为index节点*/ vv.updatePre(i,index); /*更新出发顶点到i的距离*/ vv.updateDis(i,len); } } }
执行结果:
2.弗洛伊德算法(求出所有顶点到其他各个顶点的最短距离)
步骤:
1.设顶点vi到vk的最短路径已知是Lik,顶点vk到vj的最短路径已知是Lkj,顶点vi到vj的路径为Lij,那么vi到vj的最短路径是min((Lik+Lkj),Lij),vk的取值为图中所有的顶点
则可以获得vi到vj的最短路径
2.vi到vk的最短路径Lik,vj到vk的最短路径Lkj,可以用同样的方式获得(递归)
初始化图
public static void main(String[] args) { char[] vertexes = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' }; //创建邻接矩阵 int[][] matrix = new int[vertexes.length][vertexes.length]; final int N = 65535; matrix[0] = new int[] { 0, 5, 7, N, N, N, 2 }; matrix[1] = new int[] { 5, 0, N, 9, N, N, 3 }; matrix[2] = new int[] { 7, N, 0, N, 8, N, N }; matrix[3] = new int[] { N, 9, N, 0, N, 4, N }; matrix[4] = new int[] { N, N, 8, N, 0, 5, 4 }; matrix[5] = new int[] { N, N, N, 4, 5, 0, 6 }; matrix[6] = new int[] { 2, 3, N, N, 4, 6, 0 }; FGraph fGraph = new FGraph(vertexes,matrix,vertexes.length); fGraph.show(); } class FGraph{ public char[] vertexes; // 存放各个顶点的数组 public int[][] dis; // 存放各个顶点到其他各顶点的距离 public int[][] pre; // 存放到达目标顶点的前驱节点 /** * 初始化顶点,dis,pre * @param vertexes * @param matrix * @param length */ public FGraph(char[] vertexes, int[][] matrix, int length) { this.vertexes = vertexes; this.dis = matrix; /*对pre数组进行初始化,存放的是前驱节点的下标*/ this.pre = new int[length][length]; for (int i = 0; i < length; i++) { Arrays.fill(pre[i], i); } } public void show() { for(int k = 0; k < dis.length;k++){ // 输出pre for (int j = 0; j < dis.length; j++) { System.out.print(vertexes[pre[k][j]] + " "); } System.out.println(); // 输出dis for (int i = 0; i < dis.length; i++) { System.out.print("(" + vertexes[k] + "到"+vertexes[i]+"的最短路径是: " + dis[k][i] + ") "); } System.out.println(); } } }
实现算法(vki+vkj < vij)
public void floyd(){ int len = 0; // 保存距离 /*对中间节点进行遍历,k就是中间节点的下标 [A, B, C, D, E, F, G] */ for (int k = 0; k < dis.length; k++) { /*从i顶点开始出发 [A, B, C, D, E, F, G] */ for (int i = 0; i < dis.length; i++) { /*到达j顶点 [A, B, C, D, E, F, G] */ for (int j = 0; j < dis.length; j++) { /*计算出从i出发,经过k中间节点,到达j的距离*/ len = dis[i][k] + dis[k][j]; if (len < dis[i][j]) {/*如果len小于原本的距离*/ /*更新距离表*/ dis[i][j] = len; /*更新前驱节点*/ pre[i][j] = pre[k][j]; } } } } }
执行结果:
