Java邻接矩阵存储图简易版以及深度优先优先遍历和广度优先遍历

数据结构课上学的邻接表存储图只能用来学习使用，真正写算法题的是否如果也写那么多个类，构建图和DFS操作这么多还这么复杂，那肯定时间不够，所以下面介绍一种刷题的时候比较实用的一种方式，一般不需要创建类，或者最多只需创建一个类

如果每个边没有权重，使用ArrayList<LinkedList<Integer> G来存储图

public class Solution1 {
    // 邻接表存储图
    public static final int MAXV = 1000;
    public static boolean[] vis = new boolean[MAXV];
    public static int n;
    //
    public static ArrayList<LinkedList<Integer>> G = new ArrayList<>(MAXV);  // 存储图的邻接表

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 读取一个图的数据
        n = in.nextInt();
        int e = in.nextInt();

        // 读取所有边的数据
        for(int i = 0; i < e; i++){
            int u = in.nextInt();
            int v = in.nextInt();
            G.get(u).add(v);
            G.get(v).add(u);
        }

        // DFS遍历图
        DFSTrave();

    }
}

深度优先遍历

public static void DFSTrave(){
    for(int u = 0; u < n; u++){
        if(vis[u] == false){
            DFS(u, 1);
        }
    }
}

// 从u顶点开始遍历该连通分量
private static void DFS(int u, int depth) {
    vis[u] = true;      // 设置u已被访问
    // 遍历u的所有邻接点
    for(int i = 0; i < G.get(u).size(); i++){
        int v = G.get(u).get(i);
        if(vis[v] == false){        // 如果这个邻接点没有访问过，DFS访问它
            DFS(v, depth + 1);
        }
    }
}

广度优先遍历

public static boolean[] inq  = new boolean[MAXV];
private static void BFS(int u) {
    // 初始化inq数组
    Arrays.fill(inq, false);
    Queue<Integer> queue = new LinkedList<Integer>();
    // 入队u
    queue.offer(u);
    // 标记u已入队
    inq[u] = true;

    // 循环
    while(!queue.isEmpty()){
        // 出队队首元素
        Integer top = queue.poll();

        // 所有未入队邻接点入队
        for(int i = 0; i < G.get(top).size(); i++){
            int v = G.get(top).get(i);
            if(inq[v] == false){
                queue.offer(v);
                inq[v] = true;
            }
        }

    }
}

如果边有权重，需要创建一个类来表示AdjV邻接点, 使用ArrayList<LinkedList<AdjV>> G来存储图

public class Solution2 {
    // 邻接表存储图
    public static final int MAXV = 1000;
    public static boolean[] vis = new boolean[MAXV];
    public static int n;
    
    public static class AdjV{
        public int v;         // 邻接点
        public int weight;  // 边的权重
        public AdjV(int v, int weight){
            this.v = v;
            this.weight = weight;
        }
    }
    
    public static ArrayList<LinkedList<AdjV>> G = new ArrayList<>(MAXV);  // 存储图的邻接表

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 读取一个图的数据
        n = in.nextInt();
        int e = in.nextInt();

        // 读取所有边的数据
        for(int i = 0; i < e; i++){
            int u = in.nextInt();
            int v = in.nextInt();
            int weight = in.nextInt();
            G.get(u).add(new AdjV(v, weight));
            G.get(v).add(new AdjV(u, weight));
        }

        // DFS遍历图
        DFSTrave();

    }
}

对应的深度优先遍历

public static void DFSTrave(){
    for(int u = 0; u < n; u++){
        if(vis[u] == false){
            DFS(u, 1);
        }
    }
}

// 从u顶点开始遍历该连通分量
private static void DFS(int u, int depth) {
    vis[u] = true;      // 设置u已被访问
    // 遍历u的所有邻接点
    for(int i = 0; i < G.get(u).size(); i++){
        AdjV adjV = G.get(u).get(i);
        if(vis[adjV.v] == false){        // 如果这个邻接点没有访问过，DFS访问它
            DFS(adjV.v, depth + 1);
        }
    }
}

广度优先遍历，

public static void DFSTrave(){
    for(int u = 0; u < n; u++){
        if(vis[u] == false){
            BFS(u);     // 遍历u所在的连通块
        }
    }
}

public static boolean[] inq  = new boolean[MAXV];
private static void BFS(int u) {
    // 初始化inq数组
    Arrays.fill(inq, false);
    Queue<Integer> queue = new LinkedList<>();
    // 入队u
    queue.offer(u);
    // 标记u已入队
    inq[u] = true;

    // 循环
    while(!queue.isEmpty()){
        // 出队队首元素
        Integer top = queue.poll();

        // 所有未入队邻接点入队
        for(int i = 0; i < G.get(top).size(); i++){
            AdjV adjV = G.get(top).get(i);
            if(inq[adjV.v] == false){
                queue.offer(adjV.v);
                inq[adjV.v] = true;
            }
        }

    }
}