本文链接：https://blog.csdn.net/weixin_42493179/article/details/88421343

public class GraphTest {

   public static void main(String[] args) {
       final int MAXVAL = 1000;
       Graph graph = new Graph(9);
       /*
       int[] a0 = new int[] {0,MAXVAL,MAXVAL,MAXVAL,6};
       int[] a1 = new int[] {9,0,3,MAXVAL,MAXVAL};
       int[] a2 = new int[] {2,MAXVAL,0,5,MAXVAL};
       int[] a3 = new int[] {MAXVAL,MAXVAL,MAXVAL,0,4};
       int[] a4 = new int[] {MAXVAL,MAXVAL,MAXVAL,MAXVAL,0};

       int[][] array = new int[5][];
       array[0] = a0;
       array[1] = a1;
       array[2] = a2;
       array[3] = a3;
       array[4] = a4;
       graph.setMatrix(array);
       */

       int[] a0 = new int[] {0,10,MAXVAL,MAXVAL,MAXVAL,11,MAXVAL,MAXVAL,MAXVAL};
       int[] a1 = new int[] {10,0,18,MAXVAL,MAXVAL,MAXVAL,16,MAXVAL,12};
       int[] a2 = new int[] {MAXVAL,MAXVAL,0,22,MAXVAL,MAXVAL,MAXVAL,MAXVAL,8};
       int[] a3 = new int[] {MAXVAL,MAXVAL,22,0,20,MAXVAL,MAXVAL,16,21};
       int[] a4 = new int[] {MAXVAL,MAXVAL,MAXVAL,20,0,26,MAXVAL,7,MAXVAL};
       int[] a5 = new int[] {11,MAXVAL,MAXVAL,MAXVAL,26,0,17,MAXVAL,MAXVAL};
       int[] a6 = new int[] {MAXVAL,16,MAXVAL,MAXVAL,MAXVAL,17,0,19,MAXVAL};
       int[] a7 = new int[] {MAXVAL,MAXVAL,MAXVAL,16,7,MAXVAL,19,0,MAXVAL};
       int[] a8 = new int[] {MAXVAL,12,8,21,MAXVAL,MAXVAL,MAXVAL,MAXVAL,0};

       int[][] array = new int[9][];
       array[0] = a0;
       array[1] = a1;
       array[2] = a2;
       array[3] = a3;
       array[4] = a4;
       array[5] = a5;
       array[6] = a6;
       array[7] = a7;
       array[8] = a8;

       graph.setMatrix(array);

       int degree = graph.getOutDegree(6);
       System.out.println("该节点的出度为："+degree);
       int a = graph.getInDegree(6);
       System.out.println("该节点的入度为："+a);
       int b = graph.getWeightByTwoNode(2,3);
       System.out.println("两个节点的濃值为："+b);
       graph.depthFirstSearch();
       graph.primAlgorithm();

   }
}
class Graph {
   private static final int MAXVAL = 1000;

   private int vertexSize ;

   private int[] vertex;/**存储顶点的一维数组**/

   private int[][] matrix;/**存储濃值的二维数组**/

   private boolean[] isVisited;/**定义一个布尔类型的数组，用于判断图中的节点是忦被鿿历过**/

   public Graph(int vertexSize) {
       /**
       * 1:刿始化数濮的个数 2：刿始化一个存储顶点的一维数组 3：刿始化一个存储边的二维数组**/
       this.vertexSize = vertexSize;
       vertex = new int[vertexSize];
       for(int i=0;i<vertexSize;i++) {
           vertex[i] = i;
       }
       matrix = new int[vertexSize][vertexSize];

       isVisited = new boolean[vertexSize];
   }

   public void setMatrix(int i, int[] a0) {

   }

   public int getVertexSize() {
       return vertexSize;
   }

   public void setVertexSize(int vertexSize) {
       this.vertexSize = vertexSize;
   }

   public int[] getVertex() {
       return vertex;
   }

   public void setVertex(int[] vertex) {
       this.vertex = vertex;
   }

   public void setMatrix(int[][] matrix) {
       this.matrix = matrix;
   }

   public int[][] getMatrix() {
       return matrix;
   }

   /**
   * 计算图中柿个节点的出度**/
   public int getOutDegree(int index) {
       if(index < 0) {
           return -1;
       }
       int degree = 0;
       for(int i=0;i<matrix[index].length;i++) {
           int weight = matrix[index][i];
           if(weight != 0 && weight != MAXVAL) {
               degree++;
           }
       }
       return degree;
   }

   /**
   * 计算图中柿个节点的入度**/
   public int getInDegree(int index) {
       if(index < 0) {
           return -1;
       }
       int degree = 0;
       for(int i=0;i<matrix.length;i++) {
           int weight = matrix[i][index];
           if(weight != MAXVAL && weight != 0) {
               degree++;
           }
       }
       return degree;
   }

   /**
   * 计算两个节点的濃值**/
   public int getWeightByTwoNode(int index_1,int index_2) {
       if(matrix[index_1][index_2] == MAXVAL) {
           return -1;
       }else if(matrix[index_1][index_2] == 0) {
           return 0;
       }else {
           return matrix[index_1][index_2];
       }
   }

   /**
   * 获忖柿个节点的第一个邻接点**/
   public int getFirstNeiborhodeNode(int index) {
       if(index < 0) {
           return -1;
       }
       for(int i=0;i<matrix[index].length;i++) {
           if(matrix[index][i] > 0 && matrix[index][i] < MAXVAL) {
               return i;
           }
       }
       return -1;
   }

   /**
   * 获忖柿个节点的第一个邻接点的下一个邻接点。 v代表正在鿿历的节点，firstNode代表v的第一个邻接点**/
   public int getFirstNodeNext(int v,int firstNodeIndex) {
       if(v < 0 || firstNodeIndex < 0) {
           return -1;
       }
       for(int i=firstNodeIndex+1;i<matrix[v].length;i++) {
           if(matrix[v][i] > 0 && matrix[v][i] < MAXVAL) {
               return i;
           }
       }
       return -1;
   }

   /**
   * 图的深度优先鿿历内部方法**/
   private void depthFirstSearch(int vertex) {
       isVisited[vertex] = true;
       int neiborNode = getFirstNeiborhodeNode(vertex);
       while(neiborNode != -1) {
           if(!isVisited[neiborNode]) {

               depthFirstSearch(neiborNode);
           }
           neiborNode = getFirstNodeNext(vertex,neiborNode);
       }
   }

   /**
   * 对外公开的深度优先鿿历算法**/
   public void depthFirstSearch() {
       isVisited = new boolean[vertexSize];
       for(int i=0;i<vertexSize;i++) {
           System.out.println("正在鿿历的节点："+i);
           if(!isVisited[i]) {
               depthFirstSearch(i);
           }
       }
       isVisited = new boolean[vertexSize];
   }

   /**
   * 普里姆算法---图的最尿鿿历算法
   * 构造最尿生房树的规则：
   * 1.尽釿选忖濃值最尿的边，但是丿能构房回路
   * 2.最尿生房树的边数总和为n-1**/
   public void primAlgorithm() {
       /**存储最尿定点濃值的数组，为0表示该顶点已绿找到最尿濃值**/
       int[] minWeightCostArray = new int[vertexSize];
       //int[] weightValue = new int[vertexSize];/**存放顶点值**/
       int minWeight,minId,sum = 0;/**定义最尿濃值忘釿，最尿濃值id,最尿濃值总和**/
       /**存储的是二维矩阵中下标为0的那一行数濮**/
       for(int i=0;i<vertexSize;i++) {
           minWeightCostArray[i] = matrix[0][i];
       }
       /**刿始化忘釿,因为在上鿢的for循环中已绿鿿历了第一行数濮，所以在这里忪需覿鿿历8次忳忯**/
       for(int i=1;i<vertexSize;i++) {
           minWeight = MAXVAL;
           minId = 0;
           /**作用：找到毿一行中的最尿濃值，然忎将最尿濃值赋值给minWeight**/
           for(int j=0;j<vertexSize;j++) {
               if(minWeightCostArray[j] > 0 && minWeightCostArray[j] < minWeight) {
                   minWeight = minWeightCostArray[j];
                   minId = j;
               }
           }
           System.out.println("顶点： "+minId+"最尿濃值： "+minWeight);
           //System.out.print(minId+"-->");
           sum+=minWeight;
           minWeightCostArray[minId] = 0;
           for(int k=0;k<vertexSize;k++) {
               /**
               * 将濃值最尿的索引行数濮与最尿濃值数组中的数濮进行比较，并且替濢**/
               if(minWeightCostArray[k] != 0 && matrix[minId][k] < minWeightCostArray[k]) {
                   minWeightCostArray[k] = matrix[minId][k];
                   //weightValue[k] = minId;
               }
           }

       }
       System.out.println("总和： "+sum);
   }

}

java数据结构------图