Java 数据结构之图

图的表示及实现深度优先遍历和广度优先遍历

代码实现：

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;

public class Graph {
    private int V;//顶点数
    private int E;//边数
    private ArrayList<Integer>[] adj;//邻接表

    public Graph(int v) {
        if (v < 0) throw new IllegalArgumentException("Number of vertices must be nonnegative");
        V = v;
        E = 0;
        adj = new ArrayList[V + 1];
        for (int i = 0; i <= this.V; i++) {
            adj[i] = new ArrayList<Integer>();
        }
    }

    public void addEdge(int v, int w) {
        /********** Begin *********/
        adj[v].add(w);
        adj[w].add(v);
        E++;
        /********** End *********/
    }
    
    public void DFS(int v) {
        /********** Begin *********/
        marked[v] = true;
        System.out.print(v+" ");
        for (int w:adj[v]) {
            if (!marked[w]) DFS(w);
        }
        /********** End *********/
    }
    
    public void BFS(int s) {
        /********** Begin *********/
        Queue<Integer> queue = new LinkedList<>();
        queue.add(s);
        while (!queue.isEmpty()){
            s = queue.poll();
            if (!marked[s]){
                marked[s] = true;
                System.out.print(s+" ");
            }
            for (int w:adj[s]) {
                if (!marked[w]) {
                    marked[w] = true;
                    queue.add(w);
                    System.out.print(w+" ");
                }
            }
        }
        /********** End *********/
    }

    public String toString() {
        StringBuilder s = new StringBuilder();
        s.append(V + " 个顶点, " + E + " 条边\n");
        for (int v = 1; v <= V; v++) {
            s.append(v + ": ");
            for (int w : adj[v]) {
                s.append(w + " ");
            }
            s.append("\n");
        }
        return s.toString();
    }
}

迪杰斯特拉算法实现单源最短路径问题

代码实现：

import java.util.*;

public class ShortestPath {
    private int V;//顶点数
    private int E;//边数
    private int[] dist;
    private ArrayList<Integer>[] adj;//邻接表
    private int[][] weight;//权重


    public ShortestPath(int v, int e) {
        V = v;
        E = e;
        dist = new int[V + 1];
        adj = new ArrayList[V + 1];
        weight = new int[V + 1][V + 1];
        for (int i = 0; i <= this.V; i++) {
            adj[i] = new ArrayList<Integer>();
        }
    }

    public void addEdge(int u, int v, int w) {
        adj[u].add(v);
        adj[v].add(u);
        weight[u][v] = weight[v][u] = w;
    }

    public int[] Paths(int source) {
        /********** Begin *********/
        int INF = Integer.MAX_VALUE;
        boolean[] marked = new boolean[weight.length];
        for (int m = 0;m < weight.length;m++){
            for (int w = 0;w < weight[m].length;w++){
                if (weight[m][w] == 0) weight[m][w] = INF;
            }
        }
        for (int i = 0;i < adj.length;i++){
            dist[i] = weight[source][i];
        }
        marked[source] = true;
        dist[source] = 0;
        int k = 0;
        for (int i = 1;i < adj.length;i++){
            int min = INF;
            for (int j = 0;j < adj.length;j++){
                if (!marked[j]&&dist[j]<min){
                    min = dist[j];
                    k = j;
                }
            }
            marked[k] = true;
            for (int j = 0;j < adj.length;j++){
                int tmp = weight[k][j];
                tmp = (tmp == INF?INF:(min+tmp));
                if (!marked[j]&&(tmp<dist[j])){
                    dist[j] = tmp;
                }
            }
        }
        return dist;
        /********** End *********/
    }

    /**
     * 打印源点到所有顶点的距离，INF为无穷大
     *
     * @param dist
     */
    public void print(int[] dist) {
        for (int i = 1; i <= V; i++) {
            if (dist[i] == Integer.MAX_VALUE) {
                System.out.print("INF ");
            } else {
                System.out.print(dist[i] + " ");
            }
        }
    }

}

测试代码：

import java.util.Scanner;

public class ShortestPathTest {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int E = in.nextInt();
        int V = in.nextInt();
        ShortestPath path = new ShortestPath(E, V);
        for (int i = 0; i < V; i++) {
            int u = in.nextInt();
            int v = in.nextInt();
            int w = in.nextInt();
            path.addEdge(u, v, w);
        }
        int dis[] = path.Paths(1);
        path.print(dis);
//        System.out.println(Arrays.toString(dis));
    }
}