Java程序，使用DFS和用户提供的邻接矩阵在无向图中显示连接组件的数量

正如标题所说，我需要创建一个Java程序，使用用户提供的邻接矩阵计算一个无向图中有多少连接的组件。我花了很多时间，成功地获得了邻接矩阵，并计算了有多少顶点没有连接到我的“源”顶点。但是，我无法将其打包并计算连接的组件。这对我来说太难了。请帮忙，谢谢。这是我的代码的当前状态：

import java.util.InputMismatchException;
import java.util.Scanner;
import java.util.Stack;
import java.util.Arrays;

public class UndirectedConnectivityDfs
{
    private Stack<Integer> stack;

    public UndirectedConnectivityDfs() 
    {
        stack = new Stack<Integer>();
    } 

    public void dfs(int adjacency_matrix[][], int source)
    {
        int number_of_nodes = adjacency_matrix[source].length - 1;  
        int visited[] = new int[number_of_nodes + 1];   
        visited[0]=1;
        int element = source;       
        int i = source;
        int cc=1;
          for (int k = 1; k <= number_of_nodes; k++){
             if (visited[k] == 0) 
            {
         visited[source] = 1;       
        stack.push(source);        
        while (!stack.isEmpty())
        {
            element = stack.peek();
            i = element;    
        while (i <= number_of_nodes)
        {
                if (adjacency_matrix[element][i] == 1 && visited[i] == 0)
            {
                    stack.push(i);
                    visited[i] = 1;
                    element = i;
                    i = 1;
                continue;
                }
                i++;
        }
            stack.pop();    
        }
        boolean connected = false;

        for (int vertex = 1; vertex <= number_of_nodes; vertex++)
        {
            if (visited[vertex] == 1) 
            {
                connected = true;
            } else
            {
                connected = false;
                            }
        }

           }else
        {
            System.out.print("There are ");
            System.out.print(cc);
            System.out.println(" connected compoments");
        }
}
}

    public static void main(String...arg)
    {
        int number_of_nodes, source;
        Scanner scanner = null;
    try
        {
        System.out.println("Enter the number of nodes in the graph");
            scanner = new Scanner(System.in);
            number_of_nodes = scanner.nextInt();

        int adjacency_matrix[][] = new int[number_of_nodes + 1][number_of_nodes + 1];
        System.out.println("Enter the adjacency matrix");
        for (int i = 1; i <= number_of_nodes; i++)
           for (int j = 1; j <= number_of_nodes; j++)
                   adjacency_matrix[i][j] = scanner.nextInt();

        for (int i = 1; i <= number_of_nodes; i++)
            {
                for (int j = 1; j <= number_of_nodes; j++)
                {   
                     if (adjacency_matrix[i][j] == 1 && adjacency_matrix[j][i] == 0)
                     {
                         adjacency_matrix[j][i] = 1;
                     }
                }
            }           

        System.out.println("Enter the source for the graph");
            source = scanner.nextInt(); 

            UndirectedConnectivityDfs undirectedConnectivity= new UndirectedConnectivityDfs();
            undirectedConnectivity.dfs(adjacency_matrix, source);   

        }catch(InputMismatchException inputMismatch)
        {
            System.out.println("Wrong Input format");
        }   
        scanner.close();    
    }   
}

import java.util.InputMismatchException；
导入java.util.Scanner；
导入java.util.Stack；
导入java.util.array；
公共类无向连接YDFS
{
私有堆栈；
公共无向连接YDFS（）
{
堆栈=新堆栈（）；
} 
公共无效dfs（整数邻接矩阵[][]，整数源）
{
节点的整数=邻接矩阵[source]。长度-1；
访问的int[]=新int[节点的数量+1]；
访问量[0]=1；
int元素=源；
int i=源；
int cc=1；
for（int k=1；k您的解决方案几乎完成了。您必须将变量的范围调整到检查
访问的
数组的for循环内。您还必须使用从0开始的索引，因为您可能会导致
ArrayIndexOutOfBoundsException
。此外，您不必将源作为输入。
以下是固定代码：

public class UndirectedConnectivityDfs
{
    private Stack<Integer> stack;
    public UndirectedConnectivityDfs() 
    {
            stack = new Stack<Integer>();
    } 

    public void dfs(int adjacency_matrix[][])
    {
        int number_of_nodes = adjacency_matrix[0].length;   
        int visited[] = new int[number_of_nodes];       
        int cc = 0;
        for  (int vertex = 0; vertex < number_of_nodes; vertex++)
        {
            if (visited[vertex] == 0)
            {   
                int element = vertex;               
                int i = vertex;     
                visited[vertex] = 1;
                cc++;
                stack.push(vertex);
                while (!stack.isEmpty())
                {
                    element = stack.peek();
                    i = element;    
                    while (i < number_of_nodes)
                    {
                        if (adjacency_matrix[element][i] == 1 && visited[i] == 0)
                        {
                            stack.push(i);
                            visited[i] = 1;
                            element = i;
                            i = 1;
                            continue;
                            }
                            i++;
                    }
                    stack.pop();    
                }
            }
        }
        System.out.println("Number of Connected Components: " + cc);
    }

    public static void main(String...arg)
    {
        int number_of_nodes;
        Scanner scanner = null;
        try
        {
            System.out.println("Enter the number of nodes in the graph");
            scanner = new Scanner(System.in);

            number_of_nodes = scanner.nextInt();
            int adjacency_matrix[][] = new int[number_of_nodes][number_of_nodes];

            System.out.println("Enter the adjacency matrix");

            for (int i = 0; i < number_of_nodes; i++)
                for (int j = 0; j < number_of_nodes; j++)
                       adjacency_matrix[i][j] = scanner.nextInt();

            for (int i = 0; i < number_of_nodes; i++)
            {
                for (int j = 0; j < number_of_nodes; j++)
                {   
                    if (adjacency_matrix[i][j] == 1 && adjacency_matrix[j][i] == 0)
                    {
                            adjacency_matrix[j][i] = 1;
                    }
                    }
            }           
            UndirectedConnectivityDfs undirectedConnectivity= new UndirectedConnectivityDfs();
            undirectedConnectivity.dfs(adjacency_matrix);   

        }catch(InputMismatchException inputMismatch)
        {
            System.out.println("Wrong Input format");
        }   
        scanner.close();    
    }   
}

public类无向connectivitydfs
{
私有堆栈；
公共无向连接YDFS（）
{
堆栈=新堆栈（）；
} 
公共无效dfs（整数邻接矩阵[][]）
{
节点的整数=邻接矩阵[0]。长度；
访问的int[]=新int[节点的数量]；
int cc=0；
对于（int-vertex=0；顶点<节点数；顶点++）
{
如果（访问[顶点]==0）
{   
int元素=顶点；
int i=顶点；
访问[顶点]=1；
cc++；
堆栈推送（顶点）；
而（！stack.isEmpty（））
{
元素=stack.peek（）；
i=元素；
while（i<节点数）
{
if（邻接矩阵[element][i]==1和[i]==0）
{
堆栈推送（i）；
访问量[i]=1；
元素=i；
i=1；
持续
}
i++；
}
stack.pop（）；
}
}
}
System.out.println（“连接部件的数量：“+cc”）；
}
公共静态void main（字符串…参数）
{
节点的整数个数；
扫描器=空；
尝试
{
System.out.println（“在图中输入节点数”）；
扫描仪=新扫描仪（System.in）；
节点数=scanner.nextInt（）；
int邻接_矩阵[][]=新int[_节点数][_节点数]；
System.out.println（“输入邻接矩阵”）；
for（int i=0；i<节点数；i++）
对于（int j=0；j<节点数；j++）
邻接矩阵[i][j]=scanner.nextInt（）；
for（int i=0；i<节点数；i++）
{
对于（int j=0；j<节点数；j++）
{   
if（邻接矩阵[i][j]==1和邻接矩阵[j][i]==0）
{
邻接矩阵[j][i]=1；
}
}
}           
UndirectedConnectivityDfs undirectedConnectivity=新的UndirectedConnectivityDfs（）；
无向连通性.dfs（邻接矩阵）；
}捕获（输入不匹配异常输入不匹配）
{
System.out.println（“错误的输入格式”）；
}   
scanner.close（）；
}   
}
您好，欢迎来到StackOverflow！您能告诉我们到目前为止您尝试了什么，以便我们能进一步帮助您吗？看到代码处于当前状态是很好的，但很难说在您尝试“打包并计算连接的组件”之前/之后代码是什么样子的