java Dijkstra算法 Flod算法

稠密图

package graph;

import org.springframework.util.Assert;

public class DenseGraph {
    private int n, m;
    private boolean directed;
    private int[][] arr;

    DenseGraph(int n, boolean directed) {
        this.n = n;
        this.directed = directed;
        arr = new int[n][n];
    }

    public void addEdge(int v, int t) {
        Assert.isTrue(v < n && v >= 0);
        Assert.isTrue(t < n && t >= 0);
        if (hasEdge(v, t)) return;
        arr[v][t] = 1;
        if (!directed)
            arr[t][v] = 1;
        m++;
    }

    public void addEdge(int v, int t, int w) {
        Assert.isTrue(v < n && v >= 0);
        Assert.isTrue(t < n && t >= 0);
        if (hasEdge(v, t)) return;
        arr[v][t] = w;
        if (!directed)
            arr[t][v] = w;
        m++;
    }

    public void print() {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print(arr[i][j] + "   ");
            }
            System.out.println();
        }
    }

    public int[][] getGraph()
    {
        return arr.clone();
    }

    private boolean hasEdge(int v, int t) {
        return arr[v][t] == 1;
    }
}

稀疏图

package graph;

import org.springframework.util.Assert;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SparseGraph {
    private int n,m;
    private boolean directed;
    private Set<Integer>[] arr;

    SparseGraph(int n,boolean directed)
    {
        this.n=n;
        this.directed=directed;
        arr = new Set[n];
        for (int i=0;i<n;i++)
        {
            arr[i] = new HashSet<>();
        }
    }

    public void addEdge(int v,int t)
    {
        Assert.isTrue(v < n && v >= 0);
        Assert.isTrue(t < n && t >= 0);
        arr[v].add(t);
        if(!directed)
        {
            arr[t].add(v);
        }

        m++;
    }

    public void print()
    {
        for(int i=0;i<n;i++)
        {

            Iterator iterator= arr[i].iterator();
            System.out.print(i + ":  " );
            while (iterator.hasNext())
            {
                System.out.print(iterator.next() + "   " );
            }
            System.out.println();
        }
    }

}

寻路算法

package graph;

import java.util.HashMap;
import java.util.Map;

public class graphTest {
    public static void main(String[] args) {
//        DenseGraph denseGraph= new DenseGraph(10,false);
//        for(int i=0;i<9;i++)
//        {
//            denseGraph.addEdge(i,i+1);
//        }
//        denseGraph.print();
//
//        System.out.println();
//
//        SparseGraph sparseGraph= new SparseGraph(10,false);
//        for(int i=0;i<9;i++)
//        {
//            sparseGraph.addEdge(i,i+1);
//        }
//        sparseGraph.print();

        DenseGraph denseGraph = new DenseGraph(8, false);
        denseGraph.addEdge(0, 1, 1);
        denseGraph.addEdge(1, 2, 3);
        denseGraph.addEdge(1, 3, 1);
        denseGraph.addEdge(1, 5, 4);
        denseGraph.addEdge(2, 3, 4);
        denseGraph.addEdge(2, 4, 6);
        denseGraph.addEdge(3, 6, 2);
        denseGraph.addEdge(4, 5, 1);
        denseGraph.addEdge(4, 7, 4);
        denseGraph.addEdge(5, 6, 7);
        denseGraph.addEdge(5, 7, 1);
        denseGraph.addEdge(6, 7, 8);
        denseGraph.print();

        int[][] arr = denseGraph.getGraph();

        printDijkstraPath(arr,1);
        printFlodPath(arr);

    }

    /**
     * 加权图最短路线算法Dijkstra算法
     *
     * @param arr
     * @param start
     */
    public static void printDijkstraPath(int[][] arr, int start) {
        Map<Integer, Integer> map = new HashMap();
        Map<Integer, Integer> mapalread = new HashMap();
        Map<Integer, String> mapalreadpath = new HashMap();
        int mapfor = 0;
        int n = arr.length;
        for (int i = 0; i < n; i++) {
            map.put(i, 999999999);
        }

        for (int i = 0; i < n; i++) {
            if (arr[start][i] != 0) {
                mapalread.put(i, arr[start][i]);
                mapalreadpath.put(i, start + "->" + i);
                map.remove(i);
            }
        }

        while (map.size() != 0 && mapfor++ < n) {
            ALREADFOR:
            for (Integer key : mapalread.keySet()) {
                for (int i = 0; i < n; i++) {
                    if (arr[key][i] != 0 && i != start) {
                        if (mapalread.containsKey(i)) {
                            if (mapalread.get(i) > arr[key][i] + mapalread.get(key)) {
                                mapalread.put(i, arr[key][i] + mapalread.get(key));
                                mapalreadpath.put(i, mapalreadpath.get(key) + "->" + i);
                            }
                        } else {
                            mapalread.put(i, arr[key][i] + mapalread.get(key));
                            mapalreadpath.put(i, mapalreadpath.get(key) + "->" + i);
                            map.remove(i);
                            break ALREADFOR;
                        }
                    }
                }
            }
        }

        for (Object key : mapalread.keySet()) {
            System.out.println(mapalreadpath.get(key) + " " + mapalread.get(key));
        }
    }

    /**
     * 加权图最短路线算法Flod算法
     *
     * @param arr
     */
    public static void printFlodPath(int[][] arr) {
        System.out.println();
        int n = arr.length;
        int v = 0, w = 0, k = 0;
        int[][] parr = new int[n][n];
        // 初始化数据
        for (v = 0; v < n; ++v) {
            for (w = 0; w < n; ++w) {
                parr[v][w] = v;
            }
        }

        for (k = 0; k < n; ++k) {
            for (v = 0; v < n; ++v) {
                for (w = 0; w < n; ++w) {
                    if (arr[v][k] == 0 || arr[k][w] == 0 || arr[v][w] == 0) continue;
                    if (arr[v][w] > arr[v][k] + arr[k][w]) {
                        arr[v][w] = arr[v][k] + arr[k][w];
                        parr[v][w] = parr[k][w];
                    }
                }
            }
        }

        int temp;
        for (int i = 0; i < n; i++) {
            StringBuilder builder = new StringBuilder();
            for (int j = 0; j < n; j++) { //遍历打印任意亮点的路径
                builder.append(i).append("->").append(j)
                        .append(", weight: "). append(arr[i][j])
                        .append(":").append(i);
                temp = parr[i][j];
                while(temp != i) {
                    builder.append("->").append(temp);
                    temp = parr[temp][j];
                }
                builder.append("->").append(j).append("\n");
            }
            System.out.println(builder.toString());
        }
    }
}