Java 此代码段的时间复杂度为O（n^2）或O（n^3）

我试图计算以下两个函数的时间复杂度，但我感到困惑，因为在其中一个循环中，我正在调用一个函数。我们在计算时间复杂度时会考虑这一点。该函数在if语句条件检查中被调用，它有一个o（n）。另外，我正在使用java中的内置排序函数对列表进行排序，我是否也需要计算它

public static List<Edge> getMSTUsingKruskalAlgorithm(int[][] graph, int[] singlePort) {

        List<Edge> edges = getEdges(graph);
        List<Edge> edges2 = getEdges(graph);
        DisjointSet disjointSet = new DisjointSet(graph.length);
        int chp=1000,x=-1,y=-1;
        List<Edge> mstEdges = new ArrayList<>();

        for(int i=0;i<singlePort.length;i++){
            chp=1000;
            x=-1;
            y=-1;
             for(Edge edge:edges){
                 if(( edge.x==singlePort[i]) && (!find(singlePort,edge.y))) {
                     if(edge.w<chp){
                         chp=edge.w;
                     x=edge.x;
                     y=edge.y;

                     }

                 }

             }

             int xSet = disjointSet.find(x);
             int ySet = disjointSet.find(y);

            if (xSet != ySet) {

                disjointSet.union(x,y);
                mstEdges.add(new Edge(x,y,chp));
                edges2.remove(new Edge(x,y,chp));
                for(Edge edge2:edges)
                {
                    if(edge2.x==x || edge2.y==x)
                        edges2.remove(edge2);
                }// end of loop

            }// end of if statement 

        }// end of loop 
        Collections.sort(edges2);

        for (Edge edge : edges2) {

            int xSet = disjointSet.find(edge.x);
            int ySet = disjointSet.find(edge.y);

            if (xSet != ySet) {

                disjointSet.union(edge.x, edge.y);
                mstEdges.add(edge);
            }
        }



         return mstEdges;


    }   



private static boolean find( int [] arr, int val)
    {
        boolean x= false;
        for (int i=0;i<arr.length;i++)
            if(arr[i]==val)
            { x=true;
             break;}

        return x;
    }

publicstaticlist getmstusingkruskalagorithm（int[]]graph，int[]singlePort）{
列表边=获取边（图形）；
列表边2=获取边（图形）；
DisjointSet DisjointSet=新的DisjointSet（graph.length）；
int chp=1000，x=-1，y=-1；
List mstEdges=new ArrayList（）；
对于（inti=0；i您的外循环是
O（n）
，其中
n
是单端口中的元素数

您的内部循环是
O（m）
，其中
m
是边列表中的边数。
在这个循环中，您调用
find（singlePort）
函数-将其视为嵌套循环

find（）
函数是
O（n）
其中
n
是
arr
中的元素数，即
singlePort

您有三个级别的嵌套循环，因此可以成倍增加它们的时间复杂性。注意：退出条件始终是运行时的良好指示器

n * m * n = n^2 * m

如果
m==n
则您的算法是
O（n*n*n）=O（n^3）

否则，从它的书写方式来看，我们只能说：

O(n^2 * m)

您的外部循环是
O（n）
，其中
n
是单端口中的元素数

您的内部循环是
O（m）
，其中
m
是边列表中的边数。
在这个循环中，您调用
find（singlePort）
函数-将其视为嵌套循环

find（）
函数是
O（n）
其中
n
是
arr
中的元素数，即
singlePort

您有三个级别的嵌套循环，因此可以成倍增加它们的时间复杂性。注意：退出条件始终是运行时的良好指示器

n * m * n = n^2 * m

如果
m==n
则您的算法是
O（n*n*n）=O（n^3）

否则，从它的书写方式来看，我们只能说：

O(n^2 * m)

如果您循环方法a中的一个列表，并决定重构该方法以将该循环放入由a调用的另一个私有方法B中，这是否会改变完成该任务所需的操作数？该任务是否突然变为O（1）无论在列表中的大小是多少，都要在一定的时间内执行，你必须考虑函数内发生的所有事情。例如，你调用<代码> DeJuntStudio。在方法a中，并决定重构该方法以将循环放入由a调用的另一个私有方法B中，这是否会改变完成任务所需的操作数？任务是否突然变为O（1）即，不管列表的大小是多少，都要在一定的时间内执行。你必须考虑函数内发生的所有事情。例如，你调用<代码> DeJuntStudio。联合< /COD>和<代码> DeJuntStudio。查找< /代码>。这些操作的复杂性也必须被考虑，但是从代码中不清楚它是什么。