Java邻接矩阵表示graph并实现prim和kruskal算法

package Graph;

import jdk.swing.interop.SwingInterOpUtils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;

//邻接矩阵实现有向带权重图,及bfs，dfs，prim算法和kruskal算法
public class AdjacencyMatrixGraph2 {
    private ArrayList<Node> nodeArrayList;//存放结点数组

    private int nodeNumbers;//结点数量

    public boolean[] visited;//遍历的时候检查该结点是否已经遍历；

    private int[][] edgeMatrix;//存放边的邻接矩阵

    static final int EDGE_NONE = 65535;//边不存在

    public Queue<Node> queue;//辅助队列

    public ArrayList<Node> getNodeArrayList() {
        return nodeArrayList;
    }

    public void setNodeArrayList(ArrayList<Node> nodeArrayList) {
        this.nodeArrayList = nodeArrayList;
    }

    public int getNodeNumbers() {
        return nodeNumbers;
    }

    public void setNodeNumbers(int nodeNumbers) {
        this.nodeNumbers = nodeNumbers;
    }

    public int[][] getEdgeMatrix() {
        return edgeMatrix;
    }

    public void setEdgeMatrix(int[][] edgeMatrix) {
        this.edgeMatrix = edgeMatrix;
    }

    public AdjacencyMatrixGraph2(int numbers) {
        this.setNodeNumbers(numbers);
        this.setNodeArrayList(new ArrayList<Node>(numbers));
        this.visited = new boolean[numbers];
        this.setEdgeMatrix(new int[numbers][numbers]);
        this.queue = new LinkedList<Node>();
        for (int i = 0; i < edgeMatrix.length; i++) {
            for (int j = 0; j < edgeMatrix.length; j++) {
                edgeMatrix[i][j] = AdjacencyMatrixGraph2.EDGE_NONE;
            }
        }
    }

    @Override
    public String toString() {
        System.out.println("结点列表：" + this.nodeArrayList);
        System.out.println("邻接矩阵：");
        System.out.print("   ");
        for (int i = 0; i < nodeArrayList.size(); i++) {
            System.out.print(nodeArrayList.get(i) + "         ");
        }
        System.out.println();
        for (int i = 0; i < getNodeNumbers(); i++) {
            System.out.print(nodeArrayList.get(i) + "  ");
            for (int j = 0; j < getNodeNumbers(); j++) {
                System.out.print(this.edgeMatrix[i][j] + "   ");
            }
            System.out.println();
        }
        return "";
    }
    
    //添加顶点
    public boolean addNode(String name){
        if (this.nodeArrayList.contains(new Node(name))) return false;
        else {
            nodeArrayList.add(new Node(name));
            return true;
        }
    }
    
    //添加边
    public void addEdge(String from, String to, int weight){
        if (nodeArrayList.contains(new Node(from)) && nodeArrayList.contains(new Node(to))){
            this.edgeMatrix[nodeArrayList.indexOf(new Node(from))][nodeArrayList.indexOf(new Node(to))]
                    = weight;
            this.edgeMatrix[nodeArrayList.indexOf(new Node(to))][nodeArrayList.indexOf(new Node(from))]
                    = weight;
        }
        else {
            System.out.println("请先添加结点，再添加边");
        }
    }

    //dfs遍历图
    public void DFS(){
        System.out.println("DFS顺序：");
        for (int i = 0; i < nodeArrayList.size(); i++) {
            visited[i] = false;
        }
        for (int i = 0; i < visited.length; i++) {
            if (!visited[i]){
                depthFirstSearch(i);
            }
        }
        System.out.println();
    }
    private void depthFirstSearch(int i) {
        this.visited[i] = true;
        System.out.print("顶点" + this.nodeArrayList.get(i) + "-->");
        for (int j = 0; j < nodeArrayList.size(); j++) {
            if (this.edgeMatrix[i][j] != AdjacencyMatrixGraph2.EDGE_NONE && !this.visited[j]){
                depthFirstSearch(j);
            }
        }
    }

    //bfs遍历图
    public void BFS(){
        System.out.println("BFS顺序:");
        for (int i = 0; i < nodeArrayList.size(); i++) {
            this.visited[i] = false;//判断数组全为false
        }
        for (int i = 0; i < nodeArrayList.size(); i++) {
            if (!queue.contains(this.nodeArrayList.get(i)) && !visited[i]){
                queue.add(nodeArrayList.get(i));
                visited[i] = true;
            }
            for (int j = 0; j < nodeArrayList.size(); j++) {
                if (this.edgeMatrix[i][j] != AdjacencyMatrixGraph2.EDGE_NONE && !visited[j]){
                    queue.add(this.nodeArrayList.get(j));
                    visited[j] = true;
                }
            }
            Node a = queue.poll();
            System.out.print("顶点" + a + "-->");
        }
        System.out.println();
    }

    //prim算法找最小生成树
    public void prim(){
        Arrays.fill(visited, false);
        visited[0] = true;
        int x = -1, y = -1;
        for (int i = 0; i < nodeNumbers - 1; i++) {
            int count = 65535;
            for (int j = 0; j < nodeArrayList.size(); j++) {
                for (int k = 0; k < nodeArrayList.size(); k++) {
                    if (visited[j] && !visited[k] && count > edgeMatrix[j][k]){
                        count = edgeMatrix[j][k];
                        x = j;
                        y = k;
                    }
                }
            }
            visited[y] = true;
            System.out.println(nodeArrayList.get(x) + "-->" + nodeArrayList.get(y) + ": " + edgeMatrix[x][y]);
        }
    }

    //kruskal算法找最小生成树
    public void kruskal(){
        Arrays.fill(visited, false);
        int x = -1, y = -1;
        for (int i = 0; i < nodeNumbers - 1; i++) {
            int count = 65535;
            for (int j = 0; j < nodeArrayList.size(); j++) {
                for (int k = 0; k < nodeArrayList.size(); k++) {
                    if ((!visited[j] || !visited[k]) && count > edgeMatrix[j][k]){
                        count = edgeMatrix[j][k];
                        x = j;
                        y = k;
                    }
                }
            }
            visited[x] = true;
            visited[y] = true;
            System.out.println(nodeArrayList.get(x) + "-->" + nodeArrayList.get(y) + ": " + edgeMatrix[x][y]);
        }
    }



    public static void main(String[] args) {
        AdjacencyMatrixGraph2 a = new AdjacencyMatrixGraph2(5);
        a.addNode("a");
        a.addNode("b");
        a.addNode("c");
        a.addNode("d");
        a.addNode("e");
        a.addEdge("a", "b", 20);
        a.addEdge("a", "c", 10);
        a.addEdge("b", "e", 4);
        a.addEdge("c", "d", 5);
        a.addEdge("d", "e", 12);
        a.addEdge("b", "d", 3);
        a.addEdge("b", "c", 1);
        a.kruskal();
        System.out.println();
        a.prim();
    }
}