图论-图的深度优先遍历-Java

最新推荐文章于 2024-04-07 10:22:37 发布
最新推荐文章于 2024-04-07 10:22:37 发布
阅读量772 收藏
点赞数
分类专栏： 数据结构和算法 图论 文章标签： 深度优先 图论 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiangchufeng123/article/details/132657067
版权

回顾力扣144/94//145/102/589/590/429，熟练掌握递归和非递归写法。

图论不强调非递归。

使用邻接表

1个连通分量

在这里插入图片描述Graph.java

package Chapt02_DFS;
import java.io.File;
import java.io.IOException;
import java.util.TreeSet;
import java.util.Scanner;


/// 暂时只支持无向无权图
public class Graph {

    private int V;
    private int E;
    private TreeSet<Integer>[] adj;

    public Graph(String pathStr){

        File file = new File(pathStr);

        try(Scanner scanner = new Scanner(file)){

            V = scanner.nextInt();
            if(V < 0) throw new IllegalArgumentException("V must be non-negative");
            adj = new TreeSet[V];
            for(int i = 0; i < V; i ++)
                adj[i] = new TreeSet<Integer>();

            E = scanner.nextInt();
            if(E < 0) throw new IllegalArgumentException("E must be non-negative");

            for(int i = 0; i < E; i ++){
                int a = scanner.nextInt();
                validateVertex(a);
                int b = scanner.nextInt();
                validateVertex(b);

                if(a == b) throw new IllegalArgumentException("Self Loop is Detected!");
                if(adj[a].contains(b)) throw new IllegalArgumentException("Parallel Edges are Detected!");

                adj[a].add(b);
                adj[b].add(a);
            }
        }
        catch(IOException e){
            e.printStackTrace();
        }
    }

    private void validateVertex(int v){
        if(v < 0 || v >= V)
            throw new IllegalArgumentException("vertex " + v + "is invalid");
    }

    public int V(){
        return V;
    }

    public int E(){
        return E;
    }

    public boolean hasEdge(int v, int w){
        validateVertex(v);
        validateVertex(w);
        return adj[v].contains(w);
    }

    public Iterable<Integer> adj(int v){
        validateVertex(v);
        return adj[v];
    }

    public int degree(int v){
        validateVertex(v);
        return adj[v].size();
    }

    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();

        sb.append(String.format("V = %d, E = %d\n", V, E));
        for(int v = 0; v < V; v ++){
            sb.append(String.format("%d : ", v));
            for(int w : adj[v])
                sb.append(String.format("%d ", w));
            sb.append('\n');
        }
        return sb.toString();
    }

    public static void main(String[] args){

        Graph g = new Graph("g2.txt");
        System.out.print(g);
    }
}

GraphDFS.java

package Chapt02_DFS;

import java.util.ArrayList;

public class GraphDFS {

    private Graph G;
    private boolean[] visited;

    //order存放遍历结果
    private ArrayList<Integer> order = new ArrayList<>();

    //在构造函数中对图遍历
    public GraphDFS(Graph G){

        this.G = G;
        /* public int V(){ return V;} 返回顶点的数量*/
        visited = new boolean[G.V()];
        dfs(0); //从第0个节点开始遍历
    }

    private void dfs(int v){
        visited[v] = true; //v这个顶点遍历过了
        order.add(v); //把v放到order数组中

        //把v的相邻顶点w进行遍历，如果相邻顶点没有被访问过则递归地对w顶点进行dfs
        for(int w: G.adj(v))
            if(!visited[w])
                dfs(w);
    }

    // 返回一个可遍历的对象，具体是数组、链表、哈希表或者红黑树对用户屏蔽
    // 使用本方法访问遍历的元素
    public Iterable<Integer> order(){
        return order;
    }

    public static void main(String[] args){

        Graph g = new Graph("g2.txt");
        GraphDFS graphDFS = new GraphDFS(g);
        System.out.println(graphDFS.order());
    }
}

在这里插入图片描述

多个连通分量

在这里插入图片描述

只需要对GraphDFS中的构造函数进行改进
在这里插入图片描述
在这里插入图片描述

GraphDFS.java

package Chapt02_DFS;

import java.util.ArrayList;

public class GraphDFS {

    private Graph G;
    private boolean[] visited;

    //order存放遍历结果
    private ArrayList<Integer> order = new ArrayList<>();

    //在构造函数中对图遍历
    public GraphDFS(Graph G){

        this.G = G;
        /* public int V(){ return V;} 返回顶点的数量*/
        visited = new boolean[G.V()];

        for (int v = 0; v < G.V(); v++) {
            if(!visited[v]) dfs(v);
        }
 //       dfs(0); //从第0个节点开始遍历
    }

    private void dfs(int v){
        visited[v] = true; //v这个顶点遍历过了
        order.add(v); //把v放到order数组中

        //把v的相邻顶点w进行遍历，如果相邻顶点没有被访问过则递归地对w顶点进行dfs
        for(int w: G.adj(v))
            if(!visited[w])
                dfs(w);
    }

    // 返回一个可遍历的对象，具体是数组、链表、哈希表或者红黑树对用户屏蔽
    // 使用本方法访问遍历的元素
    public Iterable<Integer> order(){
        return order;
    }

    public static void main(String[] args){

        Graph g = new Graph("g3.txt");
        GraphDFS graphDFS = new GraphDFS(g);
        System.out.println(graphDFS.order());
    }
}

图的先序遍历和后续遍历

在这里插入图片描述

package Chapt02_DFS;

import java.util.ArrayList;

public class GraphDFS {

    private Graph G;
    private boolean[] visited;

    //order存放遍历结果
//    private ArrayList<Integer> order = new ArrayList<>();
    private ArrayList<Integer> pre = new ArrayList<>(); // 存放先序遍历的结果
    private ArrayList<Integer> post = new ArrayList<>(); // 存放后续遍历的结果


    //在构造函数中对图遍历
    public GraphDFS(Graph G){

        this.G = G;
        /* public int V(){ return V;} 返回顶点的数量*/
        visited = new boolean[G.V()];

        for (int v = 0; v < G.V(); v++) {
            if(!visited[v]) dfs(v);
        }
 //       dfs(0); //从第0个节点开始遍历
    }

    private void dfs(int v){
        visited[v] = true; //v这个顶点遍历过了
//        order.add(v); //把v放到order数组中
        pre.add(v); /*****************/

        //把v的相邻顶点w进行遍历，如果相邻顶点没有被访问过则递归地对w顶点进行dfs
        for(int w: G.adj(v))
            if(!visited[w])
                dfs(w);
        post.add(v); /*****************/
    }

    // 返回一个可遍历的对象，具体是数组、链表、哈希表或者红黑树对用户屏蔽
    // 使用本方法访问遍历的元素
    public Iterable<Integer> pre(){
        return pre;
    }
    public Iterable<Integer> post(){
        return post;
    }
    public static void main(String[] args){

        Graph g = new Graph("g3.txt");
        GraphDFS graphDFS = new GraphDFS(g);
        System.out.println(graphDFS.post());
        System.out.println(graphDFS.pre());
    }
}

在这里插入图片描述

使用邻接矩阵

逻辑一模一样
AdjMatrix.java

package Chapt02_DFS;
import java.io.*;
import java.util.ArrayList;
import java.util.Scanner;

public class AdjMatrix {

    private int V;
    private int E;
    private int[][] adj;

    public AdjMatrix(String filename){

        File file = new File(filename);

        try(Scanner scanner = new Scanner(file)){

            V = scanner.nextInt();
            if(V < 0) throw new IllegalArgumentException("V must be non-negative");
            adj = new int[V][V];

            E = scanner.nextInt();
            if(E < 0) throw new IllegalArgumentException("E must be non-negative");

            for(int i = 0; i < E; i ++){
                int a = scanner.nextInt();
                validateVertex(a);
                int b = scanner.nextInt();
                validateVertex(b);

                if(a == b) throw new IllegalArgumentException("Self Loop is Detected!");
                if(adj[a][b] == 1) throw new IllegalArgumentException("Parallel Edges are Detected!");

                adj[a][b] = 1;
                adj[b][a] = 1;
            }
        }
        catch(IOException e){
            e.printStackTrace();
        }
    }

    private void validateVertex(int v){
        if(v < 0 || v >= V)
            throw new IllegalArgumentException("vertex " + v + "is invalid");
    }

    public int V(){
        return V;
    }

    public int E(){
        return E;
    }

    public boolean hasEdge(int v, int w){
        validateVertex(v);
        validateVertex(w);
        return adj[v][w] == 1;
    }

    public ArrayList<Integer> adj(int v){
        validateVertex(v);
        ArrayList<Integer> res = new ArrayList<>();
        for(int i = 0; i < V; i ++)
            if(adj[v][i] == 1)
                res.add(i);
        return res;
    }

    public int degree(int v){
        return adj(v).size();
    }

    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();

        sb.append(String.format("V = %d, E = %d\n", V, E));
        for(int i = 0; i < V; i ++){
            for(int j = 0; j < V; j ++)
                sb.append(String.format("%d ", adj[i][j]));
            sb.append('\n');
        }
        return sb.toString();
    }

    public static void main(String[] args){

        AdjMatrix adjMatrix = new AdjMatrix("g3.txt");
        System.out.print(adjMatrix);
    }
}

AdjMatrixDFS.java

package Chapt02_DFS;
import java.util.ArrayList;

public class AdjMatrixDFS {

    private AdjMatrix G;
    private boolean[] visited;

    private ArrayList<Integer> pre = new ArrayList<>();
    private ArrayList<Integer> post = new ArrayList<>();

    public AdjMatrixDFS(AdjMatrix G){

        this.G = G;
        visited = new boolean[G.V()];
        for(int v = 0; v < G.V(); v ++)
            if(!visited[v])
                dfs(v);
    }

    private void dfs(int v){

        visited[v] = true;
        pre.add(v);
        for(int w: G.adj(v))
            if(!visited[w])
                dfs(w);
        post.add(v);
    }

    public Iterable<Integer> pre(){
        return pre;
    }

    public Iterable<Integer> post(){
        return post;
    }

    public static void main(String[] args){

        AdjMatrix g = new AdjMatrix("g3.txt");
        AdjMatrixDFS graphDFS = new AdjMatrixDFS(g);
        System.out.println("DFS preOrder : " + graphDFS.pre());
        System.out.println("DFS postOrder : " + graphDFS.post());
    }
}

在这里插入图片描述在这里插入图片描述

使用接口

Graph.java

public interface Graph {

    int V();
    int E();
    boolean hasEdge(int v, int w);
    Iterable<Integer> adj(int v);
    int degree(int v);
}

在不同的图表中重写接口里的方法，其实是把不同图的方法都抽象了出来

邻接表

import java.io.File;
import java.io.IOException;
import java.util.LinkedList;
import java.util.Scanner;

public class AdjList implements Graph{

    private int V;
    private int E;
    private LinkedList<Integer>[] adj;

    public AdjList(String pathStr){

        File file = new File(pathStr);

        try(Scanner scanner = new Scanner(file)){

            V = scanner.nextInt();
            if(V < 0) throw new IllegalArgumentException("V must be non-negative");
            adj = new LinkedList[V];
            for(int i = 0; i < V; i ++)
                adj[i] = new LinkedList<Integer>();

            E = scanner.nextInt();
            if(E < 0) throw new IllegalArgumentException("E must be non-negative");

            for(int i = 0; i < E; i ++){
                int a = scanner.nextInt();
                validateVertex(a);
                int b = scanner.nextInt();
                validateVertex(b);

                if(a == b) throw new IllegalArgumentException("Self Loop is Detected!");
                if(adj[a].contains(b)) throw new IllegalArgumentException("Parallel Edges are Detected!");

                adj[a].add(b);
                adj[b].add(a);
            }
        }
        catch(IOException e){
            e.printStackTrace();
        }
    }

    private void validateVertex(int v){
        if(v < 0 || v >= V)
            throw new IllegalArgumentException("vertex " + v + "is invalid");
    }

    public int V(){
        return V;
    }

    public int E(){
        return E;
    }

    public boolean hasEdge(int v, int w){
        validateVertex(v);
        validateVertex(w);
        return adj[v].contains(w);
    }

    public LinkedList<Integer> adj(int v){
        validateVertex(v);
        return adj[v];
    }

    public int degree(int v){
        return adj[v].size();
    }

    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();

        sb.append(String.format("V = %d, E = %d\n", V, E));
        for(int v = 0; v < V; v ++){
            sb.append(String.format("%d : ", v));
            for(int w : adj[v])
                sb.append(String.format("%d ", w));
            sb.append('\n');
        }
        return sb.toString();
    }

    public static void main(String[] args){

        Graph adjList = new AdjList("g.txt");
        System.out.print(adjList);
    }
}

邻接矩阵

import java.io.*;
import java.util.ArrayList;
import java.util.Scanner;

public class AdjMatrix implements Graph {

    private int V;
    private int E;
    private int[][] adj;

    public AdjMatrix(String filename){

        File file = new File(filename);

        try(Scanner scanner = new Scanner(file)){

            V = scanner.nextInt();
            if(V < 0) throw new IllegalArgumentException("V must be non-negative");
            adj = new int[V][V];

            E = scanner.nextInt();
            if(E < 0) throw new IllegalArgumentException("E must be non-negative");

            for(int i = 0; i < E; i ++){
                int a = scanner.nextInt();
                validateVertex(a);
                int b = scanner.nextInt();
                validateVertex(b);

                if(a == b) throw new IllegalArgumentException("Self Loop is Detected!");
                if(adj[a][b] == 1) throw new IllegalArgumentException("Parallel Edges are Detected!");

                adj[a][b] = 1;
                adj[b][a] = 1;
            }
        }
        catch(IOException e){
            e.printStackTrace();
        }
    }

    private void validateVertex(int v){
        if(v < 0 || v >= V)
            throw new IllegalArgumentException("vertex " + v + "is invalid");
    }

    public int V(){
        return V;
    }

    public int E(){
        return E;
    }

    public boolean hasEdge(int v, int w){
        validateVertex(v);
        validateVertex(w);
        return adj[v][w] == 1;
    }

    public Iterable<Integer> adj(int v){
        validateVertex(v);
        ArrayList<Integer> res = new ArrayList<>();
        for(int i = 0; i < V; i ++)
            if(adj[v][i] == 1)
                res.add(i);
        return res;
    }

    public int degree(int v){
        validateVertex(v);
        int res = 0;
        for(int i = 0; i < V; i ++)
            res += adj[v][i];
        return res;
    }

    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();

        sb.append(String.format("V = %d, E = %d\n", V, E));
        for(int i = 0; i < V; i ++){
            for(int j = 0; j < V; j ++)
                sb.append(String.format("%d ", adj[i][j]));
            sb.append('\n');
        }
        return sb.toString();
    }

    public static void main(String[] args){

        Graph adjMatrix = new AdjMatrix("g.txt");
        System.out.print(adjMatrix);
    }
}

使用红黑树构造邻接表

import java.io.File;
import java.io.IOException;
import java.util.TreeSet;
import java.util.Scanner;

public class AdjSet implements Graph{

    private int V;
    private int E;
    private TreeSet<Integer>[] adj;

    public AdjSet(String pathStr){

        File file = new File(pathStr);

        try(Scanner scanner = new Scanner(file)){

            V = scanner.nextInt();
            if(V < 0) throw new IllegalArgumentException("V must be non-negative");
            adj = new TreeSet[V];
            for(int i = 0; i < V; i ++)
                adj[i] = new TreeSet<Integer>();

            E = scanner.nextInt();
            if(E < 0) throw new IllegalArgumentException("E must be non-negative");

            for(int i = 0; i < E; i ++){
                int a = scanner.nextInt();
                validateVertex(a);
                int b = scanner.nextInt();
                validateVertex(b);

                if(a == b) throw new IllegalArgumentException("Self Loop is Detected!");
                if(adj[a].contains(b)) throw new IllegalArgumentException("Parallel Edges are Detected!");

                adj[a].add(b);
                adj[b].add(a);
            }
        }
        catch(IOException e){
            e.printStackTrace();
        }
    }

    private void validateVertex(int v){
        if(v < 0 || v >= V)
            throw new IllegalArgumentException("vertex " + v + "is invalid");
    }

    public int V(){
        return V;
    }

    public int E(){
        return E;
    }

    public boolean hasEdge(int v, int w){
        validateVertex(v);
        validateVertex(w);
        return adj[v].contains(w);
    }

    public Iterable<Integer> adj(int v){
    // public TreeSet<Integer> adj(int v){
        validateVertex(v);
        return adj[v];
    }

    public int degree(int v){
        validateVertex(v);
        return adj[v].size();
    }

    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();

        sb.append(String.format("V = %d, E = %d\n", V, E));
        for(int v = 0; v < V; v ++){
            sb.append(String.format("%d : ", v));
            for(int w : adj[v])
                sb.append(String.format("%d ", w));
            sb.append('\n');
        }
        return sb.toString();
    }

    public static void main(String[] args){

        Graph adjSet = new AdjSet("g.txt");
        System.out.print(adjSet);
    }
}

GraphDFS.java

package Chapt02_DFS;

import java.util.ArrayList;

public class GraphDFS {

    private Graph G;
    private boolean[] visited;

    private ArrayList<Integer> pre = new ArrayList<>();
    private ArrayList<Integer> post = new ArrayList<>();

    public GraphDFS(Graph G){

        this.G = G;
        visited = new boolean[G.V()];
        for(int v = 0; v < G.V(); v ++)
            if(!visited[v])
                dfs(v);
    }

    private void dfs(int v){

        visited[v] = true;
        pre.add(v);
        for(int w: G.adj(v))
            if(!visited[w])
                dfs(w);
        post.add(v);
    }

    public Iterable<Integer> pre(){
        return pre;
    }

    public Iterable<Integer> post(){
        return post;
    }

    public static void main(String[] args){

        Graph g1 = new AdjSet("g3.txt");
        GraphDFS graphDFS1 = new GraphDFS(g1);
        System.out.println("DFS preOrder : " + graphDFS1.pre());
        System.out.println("DFS postOrder : " + graphDFS1.post());
        System.out.println();

        Graph g2 = new AdjList("g3.txt");
        GraphDFS graphDFS2 = new GraphDFS(g2);
        System.out.println("DFS preOrder : " + graphDFS2.pre());
        System.out.println("DFS postOrder : " + graphDFS2.post());
        System.out.println();

        Graph g3 = new AdjMatrix("g3.txt");
        GraphDFS graphDFS3 = new GraphDFS(g3);
        System.out.println("DFS preOrder : " + graphDFS3.pre());
        System.out.println("DFS postOrder : " + graphDFS3.post());
        System.out.println();
    }
}

在这里插入图片描述

使用非递归的方法遍历图——使用栈

package Chapt02_DFS;

import java.util.ArrayList;
import java.util.Stack;

public class GraphDFSnr {

    private Graph G;
    private boolean[] visited;

    private ArrayList<Integer> pre = new ArrayList<>();


    public GraphDFSnr(Graph G){

        this.G = G;
        visited = new boolean[G.V()];
        for(int v = 0; v < G.V(); v ++)
            if(!visited[v])
                dfs(v);
    }

    private void dfs(int v){

        Stack<Integer> stack = new Stack<>();
        stack.push(v);
        visited[v] = true;
        while(!stack.empty()){
            int cur = stack.pop();
            pre.add(cur);
            for(int w: G.adj(v))
                if(!visited[w]){
                    stack.push(w);
                    visited[w] = true;
                }
        }
    }


    public Iterable<Integer> pre(){
        return pre;
    }



    public static void main(String[] args){

        Graph g1 = new AdjSet("g3.txt");
        GraphDFSnr graphDFS1 = new GraphDFSnr(g1);
        System.out.println("DFS preOrder : " + graphDFS1.pre());

        System.out.println();

        Graph g2 = new AdjList("g3.txt");
        GraphDFSnr graphDFS2 = new GraphDFSnr(g2);
        System.out.println("DFS preOrder : " + graphDFS2.pre());

        System.out.println();

        Graph g3 = new AdjMatrix("g3.txt");
        GraphDFSnr graphDFS3 = new GraphDFSnr(g3);
        System.out.println("DFS preOrder : " + graphDFS3.pre());

        System.out.println();
    }
}

在这里插入图片描述

联通分量的数量

在这里插入图片描述

public class CC {

    private Graph G;
    private boolean[] visited;
    private int cccount = 0;

    public CC(Graph G){

        this.G = G;
        visited = new boolean[G.V()];
        for(int v = 0; v < G.V(); v ++)
            if(!visited[v]){
                dfs(v);
                cccount ++; // 在if循环内
            }
    }

    private void dfs(int v){

        visited[v] = true;
        for(int w: G.adj(v))
            if(!visited[w])
                dfs(w);
    }

    public int count(){
        return cccount;
    }

    public static void main(String[] args){

        Graph g = new AdjList("g3.txt");
        CC cc = new CC(g);
        System.out.println(cc.count());
    }
}

在这里插入图片描述

具体求解无向图的联通分量

在这里插入图片描述
list并不是必要的，可以通过设置visited的值来区别不同的联通分量。

package Chapt02_DFS;
import java.util.ArrayList;

public class CC {

    private Graph G;
    private int[] visited; // boolean 设置为 int
    private int cccount = 0;

    public CC(Graph G){

        this.G = G;
        visited = new int[G.V()];
        for(int i = 0; i < visited.length; i ++)
            visited[i] = -1; // 把未遍历的设置为-1

        for(int v = 0; v < G.V(); v ++)
            if(visited[v] == -1){
                dfs(v, cccount); //dfs(int v, int ccid)，ccid初始值为ccount==0 
                cccount ++; //遍历完一组以后，ccount的值+1
            }
    }

    private void dfs(int v, int ccid){
        visited[v] = ccid;
        for(int w: G.adj(v))
            if(visited[w] == -1)
                dfs(w, ccid);
    }

    public int count(){
        for(int e: visited)
            System.out.print(e + " ");
        System.out.println();
        return cccount;
    }

    public static void main(String[] args){

        Graph g = new AdjList("g3.txt");
        CC cc = new CC(g);
        System.out.println(cc.count());
    }
}

在这里插入图片描述

判断两个顶点是否属于同一连通分量 / 这个图有多少联通分量，每个联通分量有多少顶点

把验证代码调整为public
在这里插入图片描述
Graph.java

import java.io.File;
import java.io.IOException;
import java.util.TreeSet;
import java.util.Scanner;


/// 暂时只支持无向无权图
public class Graph {

    private int V;
    private int E;
    private TreeSet<Integer>[] adj;

    public Graph(String filename){

        File file = new File(filename);

        try(Scanner scanner = new Scanner(file)){

            V = scanner.nextInt();
            if(V < 0) throw new IllegalArgumentException("V must be non-negative");
            adj = new TreeSet[V];
            for(int i = 0; i < V; i ++)
                adj[i] = new TreeSet<Integer>();

            E = scanner.nextInt();
            if(E < 0) throw new IllegalArgumentException("E must be non-negative");

            for(int i = 0; i < E; i ++){
                int a = scanner.nextInt();
                validateVertex(a);
                int b = scanner.nextInt();
                validateVertex(b);

                if(a == b) throw new IllegalArgumentException("Self Loop is Detected!");
                if(adj[a].contains(b)) throw new IllegalArgumentException("Parallel Edges are Detected!");

                adj[a].add(b);
                adj[b].add(a);
            }
        }
        catch(IOException e){
            e.printStackTrace();
        }
    }

    public void validateVertex(int v){
        if(v < 0 || v >= V)
            throw new IllegalArgumentException("vertex " + v + "is invalid");
    }

    public int V(){
        return V;
    }

    public int E(){
        return E;
    }

    public boolean hasEdge(int v, int w){
        validateVertex(v);
        validateVertex(w);
        return adj[v].contains(w);
    }

    public Iterable<Integer> adj(int v){
        validateVertex(v);
        return adj[v];
    }

    public int degree(int v){
        validateVertex(v);
        return adj[v].size();
    }

    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();

        sb.append(String.format("V = %d, E = %d\n", V, E));
        for(int v = 0; v < V; v ++){
            sb.append(String.format("%d : ", v));
            for(int w : adj[v])
                sb.append(String.format("%d ", w));
            sb.append('\n');
        }
        return sb.toString();
    }

    public static void main(String[] args){

        Graph g = new Graph("g.txt");
        System.out.print(g);
    }
}

CC.java

package Chapt02_DFS.connected;
import Chapt02_DFS.AdjList;
import Chapt02_DFS.Graph;

import java.util.ArrayList;

public class CC {

    private Graph_1 G;
    private int[] visited;
    private int cccount = 0;

    public CC(Graph_1 G){

        this.G = G;
        visited = new int[G.V()];
        for(int i = 0; i < visited.length; i ++)
            visited[i] = -1;

        for(int v = 0; v < G.V(); v ++)
            if(visited[v] == -1){
                dfs(v, cccount);
                cccount ++;
            }
    }

    private void dfs(int v, int ccid){

        visited[v] = ccid;
        for(int w: G.adj(v))
            if(visited[w] == -1)
                dfs(w, ccid);
    }

    public int count(){
        return cccount;
    }

    // 判断两个顶点是否属于同一连通分量
    public boolean isConnected(int v, int w){
        G.validateVertex(v);
        G.validateVertex(w);
        return visited[v] == visited[w];
    }

    public ArrayList<Integer>[] components(){ // 每个联通分量设置一个ArrayList

        ArrayList<Integer>[] res = new ArrayList[cccount];

        for(int i = 0; i < cccount; i ++) // 设置联通分量的ArrayList
            res[i] = new ArrayList<Integer>();

        for(int v = 0; v < G.V(); v ++) // 填充每个连通分量的ArrayList
            res[visited[v]].add(v); // visited[v]是组名，表示是哪个连通分量

        return res;
    }

    public static void main(String[] args){

        Graph_1 g = new Graph_1("g3.txt");
        CC cc = new CC(g);
        System.out.println(cc.count());

        System.out.println(cc.isConnected(0, 6));
        System.out.println(cc.isConnected(5, 6));

        ArrayList<Integer>[] comp = cc.components(); // 把res数组给了comp数组

        for(int ccid = 0; ccid < comp.length; ccid ++){ // ccid = 0、1
            System.out.print(ccid + " : ");

            for(int w: comp[ccid]) //把res[1]/res[2]里的值取出来
                System.out.print(w + " ");

            System.out.println();
        }
    }
}

在这里插入图片描述

大大枫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
javalruleetcode-Coding:记录编码问题、解决方案、解释、测试用例等
06-29
java lru leetcode 编码 此文件夹包含一些编程竞赛问题。 我试图总结问题、解决方案和我的想法。 来自： LeetCode、Codility、HackerRank、LintCode 语言： C++、Java、Python、C#、Scala 目录 1. 数学 1.1 离散数学 1.1.1 图论 1.1.1.1 图遍历（BFS、DFS） 1.1.1.2 最小生成树（Prim、Kruskal） 1.1.1.3 最短路径（Dijkstra、Floyd） 1.1.1.4 最长路径 1.1.1.5 传递闭包 1.1.1.6 铰接点 - 单向图 1.1.1.7 拓扑排序-AOV-网络 1.1.1.7.1 深度优先搜索（DFS） 1.1.1.7.2 广度优先搜索（BFS） 1.1.1.8 关键路径-AOV-网络 1.1.1.9 欧拉路径，汉密尔顿之旅 1.1.1.10 差异约束（Bellman-Ford） 1.1.1.11 二分匹配 1.1.1.12 网络流量 1.1.2 组合 1.1.3 排列 1.2 数论 1.2.1 素数 1.2.2 位 1.2.3 最大公约数（GCD） 1.2.4
高级java笔试题-Book:一些书
06-03
高级java笔试题 Welcome come to here ! Books: 链接: 提取码: 31mc 推荐一下「算法与数据结构」从入门到进阶的书单。 一.入门系列 这些书籍通过图片、打比方等通俗易懂的方法来讲述，让你能达到懂一些基础算法，线性表，堆栈，队列，树，图，DP算法，背包问题等，不要求会实现，但是看过以下这些书对于之后实现算法打下坚实的思维基础。 很适合在闲暇之余拿出来阅读一番。 1.1 《啊哈！算法》 这不过是一本有趣的算法书而已。和别的算法书比较，如果硬要说它有什么特点的话，那就是你能看懂它。 推荐理由： 本书中涉及到的数据结构有栈、队列、链表、树、并查集、堆和图等；涉及到的算法有排序、枚举、深度和广度优先搜索、图的遍历，当然还有图论中不可以缺少的四种最短路径算法、两种最小生成树算法、 割点与割边算法、二分图的最大匹配算法等 1.2《算法图解》 推荐理由：这本图解书很容易看懂，不枯燥。 书中的前三章将帮助你打下基础，带你学习二分查找、大O表示法、两种基本的数据结构以及递归等。余下的篇幅将主要介绍应用广泛的算法，具体内容包括：面对具体问题时的解决技巧，比如，何时采用贪婪
java实现图的深度优先遍历
09-26
对一个完全图，（稍加修改即可对非完全图适用），经过每个节点有且仅有一次，最后回到该节点，采用贪心算法，求出经过的最短路径。其中采用了深度优先的函数，广度优先的实现在注释中给予了实现。最后测试了五个节点的图，大家可以看看到底多少个节点之后计算机运行明显变慢。
数据结构（五）——图的深度、广度遍历（java代码实现）
qq_45473439的博客
08-07 764
邻接矩阵保存图 用邻接矩阵来保存图 package Graph; import java.util.ArrayList; import java.util.Arrays; import java.util.List; /** * @author lixiangxiang * @description * @date 2021/8/6 16:49 */ public class Graph { /** 边 */ private int[][] edges; /**
十一, Java实现图的深度优先遍历(DFS)和广度优先遍历(BFS)
菜菜的大数据开发の路
05-17 1014
文章目录11.1 图的概述11.1.1 什么是图?11.1.2 线性表, 树, 图的对比11.1.3 图的常见概念11.2 图的存储结构11.2.1 邻接矩阵（Adjacency Matrix）11.2.2 邻接表（Adjacency List）11.3 图的遍历11.3.1 图的深度优先遍历(DFS)11.3.2 图的广度优先遍历(BFS) 11.1 图的概述 11.1.1 什么是图? 图（graph）是一种数据结构，它是由顶点的有穷非空集合V和顶点之间边的集合E组成 通常表示为：G（V，E）。其中 G
数据结构与算法之深度优先遍历
weixin_47225948的博客
09-20 1667
数据结构与算法之深度优先遍历
Java实现图的深度优先遍历和广度优先遍历，深度广度优先遍历详解
04-16 2734
邻接矩阵实现图，Java实现数据结构，Java实现图的深度优先遍历，广度优先遍历
图的深度优先遍历算法java实现
qq_43456605的博客
12-26 547
深度优先遍历，也称为深度优先搜索，简称为DFS。它的实现原理为，它从图中某个顶点出发，访问此顶点，然后从v的未被访问的邻接点出发深度优先遍历图，直至图中所有和V有路径相通的顶点都被访问到。代码如下： import java.util.Scanner; class Point{ //这个类用于邻接表，因为每一个顶点在邻接表中都存在一个指向其它顶点的指针域所以要将指针域和数据域封装成一个具体的类 ...
java实现树的深度优先遍历和广度优先遍历
weixin_42988712的博客
10-27 4718
1.深度优先遍历DFS 深度优先遍历是图论中的经典算法，其利用了深度优先搜索算法可以产生目标图的相应拓扑排序表，采用拓扑排序表可以解决很多相关的图论问题，如最大路径问题等等。 深度优先搜索用**栈（stack）**来实现，整个过程可以想象成一个倒立的树形： 1、把根节点压入栈中。 2、每次从栈中弹出一个元素，搜索所有在它下一级的元素，把这些元素压入栈中。并把这个元素记为它下一级元素的前驱。 3、找到所要找的元素时结束程序。 4、如果遍历整个树还没有找到，结束程序。 递归实现 List<TreeN
Java实现图的遍历
wwb44444的博客
01-22 2155
最近又在手撕数据结构的代码，温习一遍得到了一些新的感悟。在这里全面地总结一下关于图的遍历算法逻辑，并手写Java代码实现，力图将全部实现逻辑呈现在读者面前。本文主要讲解的图的遍历算法为深度优先遍历与广度优先遍历。 一、图的实现 图的实现主要有两种方式，一种是邻接矩阵，一种是邻接表。 所谓邻接矩阵就是构建一个节点到节点的矩阵，每一行每一列都代表一个节点，矩阵的输入数据即为该位置所在的行和列对应的节点之间是否可达。一般而言，若该数值为表示不可达，为一个正数表示该条边的权值。矩阵对角线上的数值一般为0，表示
图的深度优先遍历 用Java实现
2301_77778262的博客
09-26 111
以下仅以一个遍历一个图为例。
Java实现深度优先遍历-DFS
贼賊大宝
03-14 710
Java实现深度优先遍历-DFS **实现功能：**使用深度优先遍历算法DFS计算地铁指定起点站和终点站之间的所有路径 1.构造地铁站点数据结构 地铁站点数据结构包含2个属性，1个站点名，1个邻接站点列表 import java.util.LinkedList; import java.util.List; public class StationNode { private String stationName; // 站点名称 private List <StationNod
深度优先遍历【DFS的基础代码及思路】
qq_57328462的博客
04-05 2189
深度优先遍历——Depth First Search是图论中非常重要的算法之一。 应用场合：拓扑排序、走迷宫、搜索引擎、爬虫等。 图是什么？ 1.图是一种逻辑结构，由有限个顶点与边连接组成； 2.图中，点与点之间的边不存在顺序关系，即是无序的； 3.图可以用邻接矩阵实现顺序存储，也可以通过邻接表来实现链式存储。 其中，图可以分为有向图与无向图： 深度优先搜索搜索路径为： 由上图可知，深度优先搜索就是一条路走到黑，如果走到头了，将通过一遍又一遍的返回上级，来寻找另一种可以走通的路，继.
java实现数据结构图论的广度优先和深度优先遍历算法（附源代码）
Erictr的博客
01-12 2619
java实现数据结构图论的广度优先和深度优先遍历算法（附源代码） 广度优先遍历和深度优先遍历是图论中两个比较重要的遍历算法，下面介绍这两种遍历算法，并用java代码进行实现： 一、深度优先遍历 深度优先遍历有点类似于树中的先序遍历，顺着一条线依次找到相应的节点，此时为了方便，我们往往需要一个额外的标志数组进行标记我们已经访问过得节点 算法步骤： （1）首先访问出发点V。 （2）然后依次从V出发搜索V的每个邻接点W，若W未曾访问过，则以W为新的出发点继续进行深度优先搜索遍历，直至图中所有和源点V有路径相通的顶
图的深度优先遍历(DFS)---java实现
qq_22993855的博客
09-01 3047
图的深度优先遍历(DFS)—java实现 图遍历介绍 所谓图的遍历，即是对结点的访问。一个图有那么多个结点，如何遍历这些结点，需要特定策略，一般有两种访问策略: (1)深度优先遍历 (2)广度优先遍历 深度优先遍历基本思想 图的深度优先搜索(Depth First Search) (1)深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点， 可以这样理解：每次都在访问完当前结点后首先访
java实现图的深度优先遍历dfs与广度优先遍历bfs
Groot-lin的博客
11-09 858
java实现图的深度优先遍历dfs与广度优先遍历bfs
【DFS】深度优先遍历
uihoioj的博客
12-23 156
深度优先遍历（DFS）也称为回溯，其特点是不停地做选择，直到找到满足条件的集合。129. 求根节点到叶节点数字之和。
岛屿个数（dfs)
最新发布
初九·潜龙勿用的博客
04-07 4991
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
图的深度优先遍历和广度优先遍历c语言
03-16
图的深度优先遍历和广度优先遍历是图论中的两种常用算法，它们都可以用C语言实现。 深度优先遍历（DFS）是一种递归算法，它从图的某个顶点开始遍历，沿着一条路径走到底，直到不能再走为止，然后回溯到上一个节点，继续遍历其他路径，直到遍历完整个图。DFS可以用栈来实现，也可以用递归来实现。 广度优先遍历（BFS）是一种迭代算法，它从图的某个顶点开始遍历，先访问该顶点，然后访问它的所有邻接点，再依次访问它们的邻接点，直到遍历完整个图。BFS可以用队列来实现。 下面是DFS和BFS的C语言实现示例： DFS： ```c #include <stdio.h> #include <stdlib.h> #define MAX_VERTICES 100 typedef struct { int data[MAX_VERTICES]; int top; } Stack; void initStack(Stack *s) { s->top = -1; } void push(Stack *s, int x) { s->data[++s->top] = x; } int pop(Stack *s) { return s->data[s->top--]; } int isEmpty(Stack *s) { return s->top == -1; } typedef struct { int data[MAX_VERTICES]; int front, rear; } Queue; void initQueue(Queue *q) { q->front = q->rear = ; } void enqueue(Queue *q, int x) { q->data[q->rear++] = x; } int dequeue(Queue *q) { return q->data[q->front++]; } int isEmpty(Queue *q) { return q->front == q->rear; } typedef struct { int n; int adj[MAX_VERTICES][MAX_VERTICES]; } Graph; void initGraph(Graph *g, int n) { g->n = n; for (int i = ; i < n; i++) { for (int j = ; j < n; j++) { g->adj[i][j] = ; } } } void addEdge(Graph *g, int u, int v) { g->adj[u][v] = g->adj[v][u] = 1; } void dfs(Graph *g, int v, int visited[]) { visited[v] = 1; printf("%d ", v); for (int i = ; i < g->n; i++) { if (g->adj[v][i] && !visited[i]) { dfs(g, i, visited); } } } void dfsStack(Graph *g, int v, int visited[]) { Stack s; initStack(&s); push(&s, v); visited[v] = 1; printf("%d ", v); while (!isEmpty(&s)) { int u = pop(&s); for (int i = ; i < g->n; i++) { if (g->adj[u][i] && !visited[i]) { push(&s, i); visited[i] = 1; printf("%d ", i); } } } } void bfs(Graph *g, int v, int visited[]) { Queue q; initQueue(&q); enqueue(&q, v); visited[v] = 1; printf("%d ", v); while (!isEmpty(&q)) { int u = dequeue(&q); for (int i = ; i < g->n; i++) { if (g->adj[u][i] && !visited[i]) { enqueue(&q, i); visited[i] = 1; printf("%d ", i); } } } } int main() { Graph g; int n, m, u, v; scanf("%d%d", &n, &m); initGraph(&g, n); for (int i = ; i < m; i++) { scanf("%d%d", &u, &v); addEdge(&g, u, v); } int visited[MAX_VERTICES] = {}; dfs(&g, , visited); printf("\n"); for (int i = ; i < n; i++) { visited[i] = ; } dfsStack(&g, , visited); printf("\n"); for (int i = ; i < n; i++) { visited[i] = ; } bfs(&g, , visited); printf("\n"); return ; } ``` BFS： ```c #include <stdio.h> #include <stdlib.h> #define MAX_VERTICES 100 typedef struct { int data[MAX_VERTICES]; int front, rear; } Queue; void initQueue(Queue *q) { q->front = q->rear = ; } void enqueue(Queue *q, int x) { q->data[q->rear++] = x; } int dequeue(Queue *q) { return q->data[q->front++]; } int isEmpty(Queue *q) { return q->front == q->rear; } typedef struct { int n; int adj[MAX_VERTICES][MAX_VERTICES]; } Graph; void initGraph(Graph *g, int n) { g->n = n; for (int i = ; i < n; i++) { for (int j = ; j < n; j++) { g->adj[i][j] = ; } } } void addEdge(Graph *g, int u, int v) { g->adj[u][v] = g->adj[v][u] = 1; } void bfs(Graph *g, int v, int visited[]) { Queue q; initQueue(&q); enqueue(&q, v); visited[v] = 1; printf("%d ", v); while (!isEmpty(&q)) { int u = dequeue(&q); for (int i = ; i < g->n; i++) { if (g->adj[u][i] && !visited[i]) { enqueue(&q, i); visited[i] = 1; printf("%d ", i); } } } } int main() { Graph g; int n, m, u, v; scanf("%d%d", &n, &m); initGraph(&g, n); for (int i = ; i < m; i++) { scanf("%d%d", &u, &v); addEdge(&g, u, v); } int visited[MAX_VERTICES] = {}; bfs(&g, , visited); printf("\n"); return ; } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大大枫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值