算法（图+递归排序）

图

图的深度优先遍历 邻接矩阵

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

// 图的深度优先遍历
// 采用 邻接矩阵 存储图的数据
// 包含非连通图的遍历， 返回遍历结果集合，打印
class MGraph{
   
     int n; //顶点数
     int e; //边数
     String[] vertex; // 顶点数组，存储定点编号，这里为String类型，如果顶点编号为[0 n-1],则可以不需要这个数组
     int[][] edges; // 邻接矩阵 n*n
}

public class DfsGraph {
   

    public static void main(String[] args) {
   
       // Scanner in=new Scanner(System.in);
        //new 一个图的实例
        MGraph graph=new MGraph();
        // 创建图
        creatGraph(graph);
        //打印图
        printg(graph);
        //对图进行遍历
       List<String> res= dfsGraph(graph);
        //打印遍历结果
        for (int i=0;i<res.size();i++){
   
            System.out.println(res.get(i));
        }
    }
    // 如果是连通图， 只调用此方法。给定图 和 起始点，开始遍历
    public  static String dfs( MGraph g,int start,int[] visitd,StringBuilder sb){
   
        visitd[start]=1;
       sb.append(g.vertex[start]);
        for(int i=0;i<g.n;i++){
   
            if(g.edges[start][i]>0 && visitd[i]==0){
   
                dfs(g,i,visitd,sb);
            }
        }
        return sb.toString();
    }
    // 对图进行遍历，考虑非连通图
    public  static  List<String> dfsGraph(MGraph g){
   
         int[] visitd=new int[g.n];
         List<String> res=new ArrayList<>();
         for(int i=0;i<g.n;i++){
   
             if(visitd[i]==0){
   
                 res.add(dfs(g,i,visitd,new StringBuilder()));
             }
         }
        return res;
    }

    //根据输入，创建图的邻接矩阵
    public  static  void creatGraph(MGraph graph){
   
        Scanner in=new Scanner(System.in);
        //输入顶点数
        System.out.println("输入顶点数n");
        graph.n=in.nextInt();
        graph.vertex=new String[graph.n];
        graph.edges=new int[graph.n][graph.n];

        //输入顶点编号  可选
        System.out.println("输入顶点编号");
        for (int i=0;i< graph.n;i++){
   
            graph.vertex[i]=in.next();
        }
        //输入  边的信息  可变
        System.out.println("输入  边的信息 ");
        for (int i=0;i<graph.edges.length;i++){
   
            for (int j=0;j<graph.edges.length;j++){
   
                graph.edges[i][j]=in.nextInt();
            }
        }
    }
    //打印图
    public  static  void  printg(MGraph g){
   
        for(int i=0;i<g.n;i++){
   
            System.out.print(g.vertex[i]+" ");
        }
        System.out.println();
        for (int i=0;i<g.n;i++){
   
            for (int j=0;j<g.n;j++){
   
                System.out.print(g.edges[i][j]+" ");
            }
            System.out.println();
        }
    }
}

广度优先遍历 邻接矩阵

import java.util.*;

//图的   广度优先遍历
// 采用 邻接矩阵 存储图的数据
// 包含非连通图的遍历， 返回遍历结果集合，打印
class Graph{
   
    int n; //顶点数
    int e; //边数
    String[] vertex; // 顶点数组，存储定点编号，这里为String类型，如果顶点编号为[0 n-1],则可以不需要这个数组
    int[][] edges; // 邻接矩阵 n*n  ，存放边的权值
}

public class BfsGraph {
   
    public static void main(String[] args) {
   
        //new 一个图的实例
        Graph graph=new Graph();
        // 创建图
        creatGraph(graph);
        //打印图
       // printg(graph);
        //对图进行遍历
        List<String> res= bfsGraph(graph);
        //打印遍历结果
        for (int i=0;i<res.size();i++){
   
            System.out.println(res.get(i));
        }

    }
    // 如果是连通图， 只调用此方法。给定图 和 起始点，开始遍历
    public  static String bfs( Graph g,int start,int[] visitd,StringBuilder sb){
   
        visitd[start]=1;
        sb.append(g.vertex[start]);
        Queue<Integer> que=new LinkedList<>();
        que.add(start);
        while (!que.isEmpty()){
   
            int index=que.poll();
            for(int i=0;i<g.n;i++){
   
                if(visitd[i]==0 && g.edges[index][i]></