以下算法的时间复杂度是多少？ [复制]答案

【问题标题】：What is the time complexity of the following algorithm? [duplicate]以下算法的时间复杂度是多少？ [复制]
【发布时间】：2017-05-20 12:25:49
【问题描述】：

谁能告诉我这个算法的时间复杂度是多少？请记住：第二种方法 (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; 
}

}

【问题讨论】：

标签： java algorithm time big-o complexity-theory

【解决方案1】：

你的replace方法更像是冒泡排序算法，算法复杂度是O(n*n)。

ANDfindMax 的初始值应该是Integer.MIN_VALUE。 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;
}

【讨论】：

【解决方案2】：

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

 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

所以你的内部循环数的公式是 9 + 8 + 7 + ... + 1 = 45。这大约是 1/2 n²，并且明显大于 n（我们假设在这个例子中是 10 ）。由于 big-o 符号会忽略常数值，我们可以忽略 1/2，简单地说复杂度为 O(n²)。

【讨论】：

【解决方案3】：

总复杂度为 O(n*n)。对于 findMax (int[]a, int i) 方法，在最坏的情况下，它需要 O(n) 的复杂度，因为在最坏的情况下，它将搜索 0 到最后一个元素作为最后一个存在的最大元素。

【讨论】：

【解决方案4】：

计算此类算法运行时间的最简单方法是注意findMax 运行在数组的至少一半，至少有一半的元素（前半)。

用数学说同样的话：让 T(N) 为 findMax 内循环运行的总次数：

T(N) >= 0.5N * 0.5N

⇒ T(N) >= 0.25N²

因此该算法的运行时间至少为 O(N²)。

然后请注意，findMax最多运行整个数组的所有元素，这意味着运行时间最多 O (N²).

【讨论】：