列出连通集 java实现

给定一个有N个顶点和E条边的无向图，请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1编号。进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。

输入格式:

输入第1行给出2个整数N(0)和E，分别是图的顶点数和边数。随后E行，每行给出一条边的两个端点。每行中的数字之间用1空格分隔。

输出格式:

按照"{ v​1​​ v​2​​ ... v​k​​ }"的格式，每行输出一个连通集。先输出DFS的结果，再输出BFS的结果。

输入样例:

8 6
0 7
0 1
2 0
4 1
2 4
3 5

输出样例:

{ 0 1 4 2 7 }
{ 3 5 }
{ 6 }
{ 0 1 2 7 4 }
{ 3 5 }
{ 6 }

import java.util.ArrayList;
import java.util.Scanner;
import java.util.LinkedList;
//声明一个图的边类
class EdgeElement
{
    int formvex;
    int endvex;
    int weight;
    public EdgeElement(int formvex,int endvex)
    {
        this.formvex=formvex;
        this.endvex=endvex;
        weight=1;
    }
}
//声明一个图类
class Graph 
{
    static final int maxWeight=0;
    ArrayList<Object> vex;//用来装图的顶点
    int[][] edges;//邻接数组
    boolean[] visited;//用来标记是否访问过顶点
    LinkedList<Object> queue;//在BFS中用来充当队列

    public Graph(int n)
    {
        visited=new boolean[n];
        vex=new ArrayList<Object>();
        queue=new LinkedList<Object>();
        edges=new int[n][n];

        for (int i=0;i<n ;i++ )
        {
            for (int j=0;j<n ;j++ )
            {
                if (i==j)
                    edges[i][j]=0;
                else
                    edges[i][j]=maxWeight;
            }
            visited[i]=false;
            vex.add(i);
        }
    //用边作为参数建立邻接数组
    }
    public void inPut(EdgeElement edg)
    {
        edges[edg.formvex][edg.endvex]=1;
        edges[edg.endvex][edg.formvex]=1;
    }
    //以某一顶点为起点寻找其所在连通集（DFS）
    public void serchByDFS(int i)
    {
        visited[i]=true;
        System.out.print(vex.get(i)+" ");
        for (int j=0; j<vex.size();j++ )
        {
            if (edges[i][j]==1&&visited[j]==false)
                serchByDFS(j);
        }
    }
    public void DFS()
    {
        clear(visited);
        for (int i=0;i<vex.size() ;i++ )
        {
            if (visited[i]==false)
            {
                System.out.print("{ ");
                serchByDFS(i);
                System.out.print("}");
                System.out.println();
            }
        }
    }

//以某个顶点作为起点，寻找其所在连通集（BFS）
    public void serchByBFS(int i)
    {
        visited[i]=true;
        queue.add(vex.get(i));
        while (queue.size()>0)
        {
            int n=(int)queue.remove();
            System.out.print(n+" ");
            for (int j=0; j<vex.size();j++ )
            {
                if (edges[n][j]==1&&visited[j]==false)
                {
                    visited[j]=true;
                    queue.add(vex.get(j));
                }
            }
        }
    }
    public void BFS()
    {
        clear(visited);
        for (int i=0;i<vex.size() ;i++ )
        {
            if (visited[i]==false)
            {
                System.out.print("{ ");
                serchByBFS(i);
                System.out.print("}");
                System.out.println();
            }
        }
    }
    public void clear(boolean[] arr)
    {
        for (int i=0;i<arr.length; i++)
            arr[i]=false;
    }
}

class test
{
    public static void main(String[] args)
    {
        
        Scanner sc=new Scanner(System.in);

        int num=sc.nextInt();
        int numOfEdges=sc.nextInt();
        Graph g=new Graph(num);

        for (int i=0;i<numOfEdges ;i++ )
        {
            int formvex=sc.nextInt();
            int endvex=sc.nextInt();
            g.inPut(new EdgeElement(formvex,endvex));
        }
        for (int i=0;i<num;i++ )
        {
            for (int j=0;j<num ;j++ )
            {
                System.out.print(g.edges[i][j]+" ");
            }
            System.out.println();
        }
        g.DFS();
        g.BFS();
    }
}