JAVA 算法 图 DFS BFS

图的常用概念

多 对 多

邻接矩阵

邻接表

用数组实现一个图

// 1指A 2指B
public class Graph {
    private ArrayList<String> vertexList;// 顶点集合
    private int[][] edges;// 邻接矩阵
    private int numOfEdges;// 边的数目

    public Graph(int n){
        edges = new int[n][n];
        vertexList = new ArrayList<String>(n);
        numOfEdges = 0;
    }
    // 加入顶点
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }
    /**
     *
     * @param v1 顶点
     * @param v2 顶点
     * @param weight 权重
     */
    public void insertEdge(int v1, int v2, int weight){
        edges[v1][v2]=weight;
        edges[v2][v1]=weight;
        numOfEdges++;
    }
    // 返回边的个数
    public int getNumOfEdges(){
        return numOfEdges;
    }
    // 返回节点i锁对应的数据
    public String getValue(int i){
        return vertexList.get(i);
    }
    // 返回权重
    public int getWeight(int v1, int v2){
        return edges[v1][v2];
    }
    // 展示邻接矩阵
    public  void showGraph(){
        for (int[] edge : edges) {
            System.out.println(Arrays.toString(edge));
        }
    }
}

测试

public class TestGraph {
    public static void main(String[] args) {
        Graph graph = new Graph(5);
        String[] vertexValue = {"A", "B", "C", "D", "E"};
        for (String s : vertexValue) {
            graph.insertVertex(s);
        }
        // 添加边 AB AC BC BD BE
        graph.insertEdge(0,1,1);
        graph.insertEdge(0,2,1);
        graph.insertEdge(1,2,1);
        graph.insertEdge(1,3,1);
        graph.insertEdge(1,4,1);
        graph.showGraph();
    }
}

DFS

	public int first(int index){
        for (int i = 0; i < vertexList.size(); i++) {
            if (edges[index][i]>0){
                return i;
            }
        }
        return  -1;
    }
    public int next(int v1, int v2){
        for (int i1 = v2+1; i1 < vertexList.size(); i1++) {
            if (edges[v1][v2]>0){
                return i1;
            }
        }
        return -1;
    }
    public void dfs(boolean[] isVisited, int i){
        System.out.println(this.getValue(i)+"->");
        isVisited[i]=true;
        int w = first(i);
        while (w!=-1){
            // w未被访问
            if (!isVisited[w]){
                dfs(isVisited, w);
            }
            w = next(i, w);
        }
    }
    public void dfs(){
        // 遍历所有节点进行回溯
        for (int i = 0; i < this.getNumOfEdges(); i++) {
            if(!isVisited[i]){
                dfs(isVisited,i);
            }
        }
    }

BFS

public void bfs(boolean[] isVisited, int v){
        int u; // 队列头结点
        isVisited[v] = true;
        System.out.println(this.getValue(v) + "=>");
        // 队列
        LinkedList<Integer> queue = new LinkedList();
        queue.addLast(v);
        if (queue.size() > 0){
            u = (Integer) queue.removeFirst();
            int w = first(u);
            while (w != -1){
                if (!isVisited[w]){
                    isVisited[w] = true;
                    System.out.println(this.getValue(w) + "=>");
                    queue.addLast(w);
                }
                w = next(u, w);
            }
        }
    }
    // 广度优先
    public  void bfs(){
        for (int i = 0; i < this.getNumOfEdges(); i++) {
            if (!isVisited[i]){
                bfs(isVisited, i);
            }
        }
    }