Java 以下算法的时间复杂度是多少？

有人能告诉我这个算法的时间复杂度是多少吗？ 请记住：第二个方法（findMax）-根据它获得的索引在数组上运行，这意味着该方法（findMax）并非每次都在所有数组上运行。 我认为这个算法的时间复杂度是O（n），但也许我错了

public class Q2 {


public static int[] replace(int []a)
{
    for(int i = 0; i < a.length; i++ ){
        if(i == a.length-1){
            a[i] = 0; 
       }

        int maxSubArry = findMax(a,i); 

          swap (a, i, maxSubArry);
    }
    return a; 

}


public static int findMax (int[]a, int i)
{
  //  i = i +1; 
    int tmp = 0; 
    for(i = i +1; i<a.length; i++)
    {
        if(a[i] > tmp)
            tmp = a[i];
    }
    return tmp; 
    }


public static void swap(int[]a, int i, int maxSubArry)
{
    int temp = a[i]; 
    a[i] = maxSubArry; 
    a[i+1] = temp; 
}

}

公共类Q2{
公共静态int[]替换（int[]a）
{
for（int i=0；i

您的

replace

方法更像气泡排序算法，算法复杂度为

O（n*n）

和findMax的初始值应为

整数.MIN\u值

。在

replace

中不需要if语句

public static int[] replace(int[] a) {
    for (int i = 0; i < a.length-1; i++) {
        swap(a, i, findMax(a, i));
    }
    return a;
}


public static int findMax(int[] a, int i) {
    int tmp = Integer.MIN_VALUE;
    for (i = i + 1; i < a.length; i++) {
        if (a[i] > tmp)
            tmp = a[i];
    }
    return tmp;
}

公共静态int[]replace（int[]a）{
for（int i=0；itmp）
tmp=a[i]；
}
返回tmp；
}

您可以根据示例进行计算。假设传递给replace（）的数组有10个元素（n=10）。因此，replace（）内部的循环运行10次，并将调用findMax 10次。由于findMax中的循环将仅从i+1开始运行，因此基于十个方法调用，它将运行的确切次数为（9-i）次：

---

所以你的内环数公式是9+8+7+…+1 = 45. 这大约是1/2N²，明显大于n（在本例中我们假设为10）。由于big-o表示法将忽略常量值，我们可以忽略1/2，只需简单地说复杂性为o（n²）。

总复杂性为o（n*n）。对于方法findMax（int[]a，int i），在最坏的情况下，它的复杂性为o（n），因为在最坏的情况下，它将搜索0到last元素作为last中存在的最大元素。

计算这样的算法运行时间的最简单方法是注意，

findMax

至少在数组的一半上运行，至少在数组的一半上运行（前一半）

在数学中说同样的事情：让T（N）为

findMax

内部循环运行的总次数：

T（N）>=0.5N*0.5N

⇒ T（N）>=0.25N²

因此，该算法的运行时间至少为O（N²）

然后请注意，

findMax

最多运行整个数组的所有元素，这意味着运行时间最多为O（N²）

 outer i | inner loop  | number of loops
=======================================
   0    | from 1 to 9 |     9
   1    | from 2 to 9 |     8
  ...   |  ...        |    ...
   8    | from 9 to 9 |     1
   9    | no loop     |     0