数据结构——图常用算法实现（DFS,BFS,最小生成树,最短路径,拓扑序列）

最近在复习数据结构的图的部分，所以就把这一部分的算法实现了一下，代码有注释，都能看明白，粘在编译器上就可以跑。如果有写的不好的地方请在留言区说明。

import java.util.ArrayList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
/**
 * 图的常用算法实现（邻接矩阵表示）
 * @author XiaoYe
 *
 */
public class GRAPGAPI  {
   
        public class Vertex implements Comparable<Vertex>{
   

            /**
             * 节点名称(A,B,C,D)
             */
            private String name;

            /**
             * 最短路径长度
             */
            private int minPath;

            /**
             * 最小生成树中节点链接的另一个节点的ID,两个节点之间保存着最小生成树中的边
             */
            private int anotherIDinminEdge;


            /**
             * 节点是否已经出列(是否已经处理完毕)最短路径用到
             */
            private boolean isMarked;

            public Vertex(String name){
                this.name = name;
                this.minPath = Integer.MAX_VALUE; //初始设置最短路径长度为无穷大
                this.anotherIDinminEdge=-1;
                this.setMarked(false);
            }
            public Vertex(String name, int path){
                this.name = name;
                this.minPath = path;
                this.setMarked(false);
            }
            public int getAnotherIDinminEdge() {
                return anotherIDinminEdge;
            }
            public void setAnotherIDinminEdge(int anotherIDinminEdge) {
                this.anotherIDinminEdge = anotherIDinminEdge;
            }
            public String getName() {
                return name;
            }
            public void setName(String name) {
                this.name = name;
            }
            public int getPath() {
                return minPath;
            }

            public void setPath(int path) {
                this.minPath = path;
            }

            boolean isMarked(){
                return this.isMarked;

            }

            void setMarked(boolean flag){
                this.isMarked=flag;
            }

            @Override
            public int compareTo(Vertex o) {
                return o.minPath > minPath?-1:1;
            }
        }


        public class Graph {
   

            /**
             * 顶点
             */
            private List<Vertex> vertexs;

            /**
             * 边
             */
            private int[][] edges;

            /**
             * 拓扑序列
             */
            private List<Vertex> topVertexs;

            /**
             * 没有访问的顶点,用于求最短路径
             */         
            private Queue<Vertex> unVisited;
            /**
             * 最小生成树保存在二维数组中
             */
            private int[][] minTree;


            /**
             * 初始化
             * @param vertexs
             * @param edges
             */
            public Graph(List<Vertex> vertexs, int[][] edges) {
                this.vertexs = vertexs;
                this.topVertexs=new ArrayList<GRAPGAPI.Vertex>();
                this.edges = edges;
                this.minTree=new int[this.vertexs.size()][this.vertexs.size()];
                initUnVisited();
            }

            /**
             * 深度优先搜索
             * @param id
             */
            public void  DFS(String vertexName){
                int id=getIdOfVertexName(vertexName);
                if(id==-1)return;
                vertexs.get(id).setMarked(true);
                System.out.println("遍历到"+vertexs.get(id).getName());
                List<Vertex> neighbors = getNeighbors(vertexs.get(id)); 
                for(int i=0;i<neighbors.size();i++){