Java无向图的存储结构以及遍历方式

邻接表

import java.util.*;

public class GraphTraversal {
    public static void main(String[] args) {
        int[][] edges = {{0, 1}, {0, 2}, {1, 3}, {1, 4}, {2, 5}}; // 示例的边信息
        int n = 6; // 假设节点数为 6

        List<List<Integer>> adjacencyList = buildAdjacencyList(edges, n); // 构建邻接表
        System.out.println("邻接表：" + adjacencyList);

        boolean[] visitedDFS = new boolean[n];
        dfs(adjacencyList, visitedDFS, 0); // 从节点0开始进行深度优先遍历

        boolean[] visitedBFS = new boolean[n];
        bfs(adjacencyList, visitedBFS, 0); // 从节点0开始进行广度优先遍历
    }

    // 构建邻接表
    public static List<List<Integer>> buildAdjacencyList(int[][] edges, int n) {
        List<List<Integer>> adjacencyList = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            adjacencyList.add(new ArrayList<>());
        }

        for (int[] edge : edges) {
            int u = edge[0];
            int v = edge[1];
            adjacencyList.get(u).add(v);
            adjacencyList.get(v).add(u); // 无向图需要双向连接
        }

        return adjacencyList;
    }

    // 深度优先遍历
    public static void dfs(List<List<Integer>> adjacencyList, boolean[] visited, int node) {
        visited[node] = true;
        System.out.print(node + " ");

        for (int neighbor : adjacencyList.get(node)) {
            if (!visited[neighbor]) {
                dfs(adjacencyList, visited, neighbor);
            }
        }
    }

    // 广度优先遍历
    public static void bfs(List<List<Integer>> adjacencyList, boolean[] visited, int start) {
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(start);
        visited[start] = true;

        while (!queue.isEmpty()) {
            int node = queue.poll();
            System.out.print(node + " ");

            for (int neighbor : adjacencyList.get(node)) {
                if (!visited[neighbor]) {
                    visited[neighbor] = true;
                    queue.offer(neighbor);
                }
            }
        }
    }
}

邻接矩阵

import java.util.*;

public class Grid {
    public static void main(String[] args) {
        int[][] edges = {{0, 1}, {0, 2}, {1, 3}, {1, 4}, {2, 5}}; // 示例的边信息
        int n = 6; // 假设节点数为 6

        int[][] adjacencyMatrix = buildAdjacencyMatrix(edges, n); // 构建邻接矩阵
        System.out.println("邻接矩阵：");
        printMatrix(adjacencyMatrix);

        boolean[] visitedDFS = new boolean[n];
        dfs(adjacencyMatrix, visitedDFS, 0); // 从节点0开始进行深度优先遍历

        boolean[] visitedBFS = new boolean[n];
        bfs(adjacencyMatrix, visitedBFS, 0); // 从节点0开始进行广度优先遍历
    }

    // 构建邻接矩阵
    public static int[][] buildAdjacencyMatrix(int[][] edges, int n) {
        int[][] adjacencyMatrix = new int[n][n];

        for (int[] edge : edges) {
            int u = edge[0];
            int v = edge[1];
            adjacencyMatrix[u][v] = 1;
            adjacencyMatrix[v][u] = 1; // 无向图需要双向连接
        }

        return adjacencyMatrix;
    }

    // 打印矩阵
    public static void printMatrix(int[][] matrix) {
        for (int[] row : matrix) {
            for (int cell : row) {
                System.out.print(cell + " ");
            }
            System.out.println();
        }
    }

    // 深度优先遍历
    public static void dfs(int[][] adjacencyMatrix, boolean[] visited, int node) {
        visited[node] = true;
        System.out.print(node + " ");

        for (int i = 0; i < adjacencyMatrix.length; i++) {
            if (adjacencyMatrix[node][i] == 1 && !visited[i]) {
                dfs(adjacencyMatrix, visited, i);
            }
        }
    }

    // 广度优先遍历
    public static void bfs(int[][] adjacencyMatrix, boolean[] visited, int start) {
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(start);
        visited[start] = true;

        while (!queue.isEmpty()) {
            int node = queue.poll();
            System.out.print(node + " ");

            for (int i = 0; i < adjacencyMatrix.length; i++) {
                if (adjacencyMatrix[node][i] == 1 && !visited[i]) {
                    visited[i] = true;
                    queue.offer(i);
                }
            }
        }
    }
}