数据结构-图-最小生成树

 private int edgeSize;
    private int vertexeSize;
    public static final int MAX_VALUE = Integer.MAX_VALUE;

    private List<Edge> minimumTreeEdges = new ArrayList<>(); //最小生成树  n-1
    private int[][] arc = new int[9][9];  //边集合  邻接矩阵表示方式

    /**
     * 普里姆构建最小生成树
     */
    public void buildMinimumTreeByPrim() {

        int[] minimumLine = new int[vertexeSize];
        int[] minimumLine2LastSearched = new int[vertexeSize];  //这里是记录上一次最小权值节点的下标

        for (int i = 1; i < vertexeSize; i++) {
            minimumLine[i] = arc[0][i]; //首先将第一排的数据作为最小的一列值后面将从这其中查找最小权值
            minimumLine2LastSearched[i] = 0;
        }
        minimumLine[0] = 0;  //0已经在加入到了遍历过的节点中去
        minimumLine2LastSearched[0] = 0;//表示0是0的上一次的最小权值（因为0是开始，所以前面还是0了）
        for (int i = 1; i < vertexeSize; i++) {
            int k = 0, min = MAX_VALUE;
            for (int j = 1; j < vertexeSize; j++) {
                if (minimumLine[j] != 0 && minimumLine[j] < min) {  //这里是找目前所有的边中权值最小的那个
                    min = minimumLine[j];
                    k = j;
                }
            }

//            NotBoundEdge edge = new NotBoundEdge(minimumLine2LastSearched[k], k); //如果是第一次的话 为0 因为由0这个最小权值计算出了k这个最小权值
//            minimumTreeEdges.add(edge);
            System.out.println("("+minimumLine2LastSearched[k]+","+k+")");
            minimumLine[k] = 0; //因为这个k已经遍历过了 所以设置为0
            for (int j = 0; j < vertexeSize; j++) {
                if (minimumLine[j] != 0 && arc[k][j] < minimumLine[j]) {
                    minimumLine[j] = arc[k][j];  //如果有比其他更小权值得节点 那么就覆盖（更大的权值已经没有任何意义了）
                    minimumLine2LastSearched[j] = k;  //这里就表示k是j的上一个节点（如果权值最小 也就是： (k,j)）
                }
            }
        }
    }

private NetNode[] netNodes=new NetNode[15];

 /**
     * TODO
     * 根据克鲁斯卡尔构建最小生成树
     */
    public void buildMinimumByKruskal() {

        int[] parent=new int[edgeSize];

        for (int i=0;i<vertexeSize;i++){
            parent[i]=0;
        }
        int m,n;
        for (int i=0;i<vertexeSize;i++){
            /**
             * 如果这里求出的n=m的话  那么就表示构成环了(
             * 因为parent[index]>0的话 就会接着往下走，直到parent[index]=0.
             * 这条路线可以看成是边连在一起的.
             * 这里就相当于从begin 和end 这两个点开始往下一直连线[直到parent[index]=0结束].
             * 如果碰到了一块(m=n) 那么就说明他们相遇了
             * )
             */
            m=findNode(parent,netNodes[i].getBegin());
            n=findNode(parent,netNodes[i].getEnd());
            if(m!=n){
                parent[n]=m;
                System.out.println("("+netNodes[i].begin+","+netNodes[i].getEnd()+")");
            }
        }

    }


    /**
     * 这里比较难理解
     * 1.这里其实就是想查看是否在用一个子集(如果parent[index]=0
     * 那就也就表示没有连在一起)
     * @param parent
     * @param index
     * @return
     */
    public int findNode(int[] parent, int index) {
        while (parent[index] > 0) {
            index = parent[index];
        }
        return index;
    }

    public interface Edge {
        int getBegin();

        int getEnd();
        int getWeight();
    }

    /**
     *
     */
    public class NetNode implements Edge {

        private int begin;
        private int end;
        private int weight;

        public int getBegin() {
            return begin;
        }

        public void setBegin(int begin) {
            this.begin = begin;
        }

        public int getEnd() {
            return end;
        }

        public void setEnd(int end) {
            this.end = end;
        }

        public int getWeight() {
            return weight;
        }

        public void setWeight(int weight) {
            this.weight = weight;
        }
    }