java如何实现graph类

Java 实现 Graph 类的关键步骤是：选择适当的数据结构、实现基本操作、处理图的遍历。 在本文中，我们将详细介绍如何在 Java 中实现 Graph 类，包括图的表示方法、基本操作、遍历算法以及一些高级操作。

一、图的表示方法

在实现 Graph 类时，首先需要选择一种合适的数据结构来表示图。常用的图表示方法有邻接矩阵和邻接表。

1. 邻接矩阵

邻接矩阵是一种二维数组，其中矩阵的每个元素表示图中两个顶点之间是否存在边。邻接矩阵适用于稠密图，即边数接近于顶点数平方的图。它的特点是查询速度快，但空间复杂度较高。

public class GraphMatrix {
    private int[][] adjacencyMatrix;
    private int numVertices;
    public GraphMatrix(int numVertices) {
        this.numVertices = numVertices;
        adjacencyMatrix = new int[numVertices][numVertices];
    }
    public void addEdge(int i, int j) {
        adjacencyMatrix[i][j] = 1;
        adjacencyMatrix[j][i] = 1;
    }
    public void removeEdge(int i, int j) {
        adjacencyMatrix[i][j] = 0;
        adjacencyMatrix[j][i] = 0;
    }
    public boolean isEdge(int i, int j) {
        return adjacencyMatrix[i][j] == 1;
    }
}

2. 邻接表

邻接表是图的另一种表示方法，适用于稀疏图，即边数远少于顶点数平方的图。邻接表使用链表来存储每个顶点的邻接顶点列表，空间复杂度较低。

import java.util.LinkedList;
public class GraphList {
    private LinkedList<Integer>[] adjacencyList;
    private int numVertices;
    public GraphList(int numVertices) {
        this.numVertices = numVertices;
        adjacencyList = new LinkedList[numVertices];
        for (int i = 0; i < numVertices; i++) {
            adjacencyList[i] = new LinkedList<>();
        }
    }
    public void addEdge(int i, int j) {
        adjacencyList[i].add(j);
        adjacencyList[j].add(i);
    }
    public void removeEdge(int i, int j) {
        adjacencyList[i].remove((Integer) j);
        adjacencyList[j].remove((Integer) i);
    }
    public LinkedList<Integer> getAdjacencyList(int i) {
        return adjacencyList[i];
    }
}

二、基本操作

1. 添加顶点和边

在图中，添加顶点和边是最基本的操作。对于邻接表表示法，可以通过简单地扩展链表来实现。

public void addVertex() {
    numVertices++;
    LinkedList<Integer>[] newAdjacencyList = new LinkedList[numVertices];
    System.arraycopy(adjacencyList, 0, newAdjacencyList, 0, adjacencyList.length);
    newAdjacencyList[numVertices - 1] = new LinkedList<>();
    adjacencyList = newAdjacencyList;
}

2. 删除顶点和边

删除顶点和边同样是图操作中的基础。对于删除顶点，需要更新邻接表中的所有相关信息。

public void removeVertex(int vertex) {
    for (int i = 0; i < numVertices; i++) {
        adjacencyList[i].remove((Integer) vertex);
    }
    LinkedList<Integer>[] newAdjacencyList = new LinkedList[numVertices - 1];
    for (int i = 0, j = 0; i < numVertices; i++) {
        if (i != vertex) {
            newAdjacencyList[j++] = adjacencyList[i];
        }
    }
    adjacencyList = newAdjacencyList;
    numVertices--;
}

三、图遍历算法

图的遍历是图论中的重要操作，主要有深度优先搜索（DFS）和广度优先搜索（BFS）。

1. 深度优先搜索（DFS）

DFS 是一种递归算法，从起始顶点开始，沿着每一条边深入到未访问的顶点，直到没有未访问的顶点为止。

public void DFS(int startVertex) {
    boolean[] visited = new boolean[numVertices];
    DFSUtil(startVertex, visited);
}
private void DFSUtil(int vertex, boolean[] visited) {
    visited[vertex] = true;
    System.out.print(vertex + " ");
    for (int v : adjacencyList[vertex]) {
        if (!visited[v]) {
            DFSUtil(v, visited);
        }
    }
}

2. 广度优先搜索（BFS）

BFS 是一种非递归算法，从起始顶点开始，先访问所有邻接顶点，再逐层向外扩展。

import java.util.LinkedList;
import java.util.Queue;
public void BFS(int startVertex) {
    boolean[] visited = new boolean[numVertices];
    Queue<Integer> queue = new LinkedList<>();
    visited[startVertex] = true;
    queue.add(startVertex);
    while (!queue.isEmpty()) {
        int vertex = queue.poll();
        System.out.print(vertex + " ");
        for (int v : adjacencyList[vertex]) {
            if (!visited[v]) {
                visited[v] = true;
                queue.add(v);
            }
        }
    }
}

四、图的高级操作

1. 最短路径算法

最短路径是图论中的重要问题之一。常用的算法有 Dijkstra 算法和 Floyd-Warshall 算法。

Dijkstra 算法

Dijkstra 算法用于找到单源最短路径，适用于非负权图。

import java.util.PriorityQueue;
import java.util.Arrays;
public int[] dijkstra(int startVertex) {
    int[] distances = new int[numVertices];
    boolean[] visited = new boolean[numVertices];
    Arrays.fill(distances, Integer.MAX_VALUE);
    distances[startVertex] = 0;
    PriorityQueue<Integer> pq = new PriorityQueue<>((v1, v2) -> distances[v1] - distances[v2]);
    pq.add(startVertex);
    while (!pq.isEmpty()) {
        int vertex = pq.poll();
        if (visited[vertex]) continue;
        visited[vertex] = true;
        for (int v : adjacencyList[vertex]) {
            int newDist = distances[vertex] + 1; // 假设边权重为1
            if (newDist < distances[v]) {
                distances[v] = newDist;
                pq.add(v);
            }
        }
    }
    return distances;
}

Floyd-Warshall 算法

Floyd-Warshall 算法用于找到所有顶点对之间的最短路径。

public int[][] floydWarshall() {
    int[][] dist = new int[numVertices][numVertices];
    for (int i = 0; i < numVertices; i++) {
        Arrays.fill(dist[i], Integer.MAX_VALUE);
        dist[i][i] = 0;
    }
    for (int i = 0; i < numVertices; i++) {
        for (int j : adjacencyList[i]) {
            dist[i][j] = 1; // 假设边权重为1
        }
    }
    for (int k = 0; k < numVertices; k++) {
        for (int i = 0; i < numVertices; i++) {
            for (int j = 0; j < numVertices; j++) {
                if (dist[i][k] != Integer.MAX_VALUE && dist[k][j] != Integer.MAX_VALUE && dist[i][k] + dist[k][j] < dist[i][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                }
            }
        }
    }
    return dist;
}

2. 最小生成树算法

最小生成树是图论中的另一个重要问题，常用算法有 Prim 算法和 Kruskal 算法。

Prim 算法

Prim 算法用于找到加权无向图的最小生成树。

import java.util.PriorityQueue;
public int[] prim() {
    int[] parent = new int[numVertices];
    int[] key = new int[numVertices];
    boolean[] inMST = new boolean[numVertices];
    Arrays.fill(key, Integer.MAX_VALUE);
    key[0] = 0;
    parent[0] = -1;
    PriorityQueue<Integer> pq = new PriorityQueue<>((v1, v2) -> key[v1] - key[v2]);
    pq.add(0);
    while (!pq.isEmpty()) {
        int u = pq.poll();
        inMST[u] = true;
        for (int v : adjacencyList[u]) {
            int weight = 1; // 假设边权重为1
            if (!inMST[v] && weight < key[v]) {
                key[v] = weight;
                pq.add(v);
                parent[v] = u;
            }
        }
    }
    return parent;
}

Kruskal 算法

Kruskal 算法通过按权重升序排序边来找到最小生成树。

import java.util.Arrays;
public class Edge implements Comparable<Edge> {
    int src, dest, weight;
    public int compareTo(Edge compareEdge) {
        return this.weight - compareEdge.weight;
    }
}
public int[] kruskal(Edge[] edges) {
    Arrays.sort(edges);
    int[] parent = new int[numVertices];
    for (int i = 0; i < numVertices; i++) {
        parent[i] = i;
    }
    Edge[] result = new Edge[numVertices - 1];
    int e = 0;
    for (Edge edge : edges) {
        int x = find(parent, edge.src);
        int y = find(parent, edge.dest);
        if (x != y) {
            result[e++] = edge;
            union(parent, x, y);
        }
    }
    return parent;
}
private int find(int[] parent, int i) {
    if (parent[i] != i) {
        parent[i] = find(parent, parent[i]);
    }
    return parent[i];
}
private void union(int[] parent, int x, int y) {
    int xRoot = find(parent, x);
    int yRoot = find(parent, y);
    parent[xRoot] = yRoot;
}

五、总结

通过本文，我们详细介绍了在 Java 中实现 Graph 类的各个方面，包括图的表示方法、基本操作、遍历算法以及一些高级操作。选择合适的数据结构、掌握基本操作和遍历算法、理解最短路径和最小生成树算法，是实现一个功能完善的 Graph 类的关键。希望本文能够帮助你更好地理解和实现 Java 中的 Graph 类。