Question

我必须计算这个算法的复杂性，我试图解决它并找到答案为O（nlogn）。这是对的吗？如果没有，请解释。

for (i=5; i<n/2; i+=5) 
{
     for (j=1; j<n; j*=4)
          op;

     x = 3*n;
     while(x > 6) 
          {op;  x--;}
}

Answer 1

Katrina，在这个例子中我们有一个O（n * log（n）） `

for (int i= 0; i < N; i++) {
       c= i;
       while (c > 0) {
         c= c/2
       }
     }

你怎么能拥有另一个包括这两个bucles。我不太确定理解算法的工作方式，但考虑到另一个用于bucle的标准方法，应该是O（n n log n

for (int j= 0; i < N); j++) { --> O(n)
   for (int i= 0; i < N; i++) { O(n)
       c= i;
       while (c > 0) { O(logn)
         c= c/2        O(1)
       }
     }
  } ?

此标准算法的后果是O（n）* O（n）* O（logn）* O（1）

所以，我认为你忘了包含另一个O（n））希望它有所帮助

Answer 2

让我们计算每个循环中的迭代次数。

最外层循环for (i=5; i<n/2; i+=5)以5为步长逐步执行n / 2和5之间的所有值。因此，它需要大约 n / 10 - 1次迭代。

有两个内环。让我们考虑第一个：for (j=1; j<n; j*=4)。对于4^x的整数，此步骤1和n之间的x格式的所有值都会逐步执行。 x的最低值为0，最高值为满足x的{{1}} - 即最接近{{1}的整数}}。因此，通过4^x < n标记迭代，我们有迭代log_4(n)。换句话说，我们对此循环进行了大约x次迭代。

现在考虑第二个内循环。它会逐步执行从0, 1, ..., log_4(n)到log_4(n) + 1的所有值。因此，迭代次数约为3 * n。

所有其他操作都有不变的运行时间，因此可以忽略。

我们如何将它们放在一起？两个内部循环按顺序运行（即，它们不是嵌套的），因此它们的运行时间只是总和：

然而，外部循环和两个内部循环是嵌套的。对于外循环的每次迭代，都运行内部循环。因此，我们将外部的迭代次数与内部的总和相乘：

3 n - 6

最后，复杂性通常用Big-O表示法表示 - 也就是说，我们只对运行时的顺序感兴趣。这意味着两件事。首先，我们可以忽略所有方面的所有常数因素。例如，(log_4(n) + 1) + (3 n - 6) = 3 n + log_4(n) - 5.变为(n / 10 - 1) * (3 n + log_4(n) - 5) = = 3 n^2 / 10 + n log_4(n) / 10 - 7 n / 2 - log_4(n) + 5.。因此我们有：

O(3 n^2 / 10)

其次，我们可以忽略所有低于具有最高顺序的术语的术语。例如，O(n^2)的排序高于O(3 n^2 / 10 + n log_4(n) / 10 - 7 n / 2 - log_4(n) + 5) = = O(n^2 + n log_4(n) - n - log_4(n) + 1).，因此我们有n。因此我们有：

最后，我们有答案。您的代码描述的算法的复杂性为O(n + 1) = O(n)。

（实际上，人们永远不会像我们在这里那样计算（近似）迭代次数。我们在最后一步中所做的简化可以提前完成，这使得计算更加容易。）

Answer 3

正如Fredrik所说，第一和第三个循环的时间复杂度为O(n)。第二个循环的时间是O(log(n))。

以下算法的复杂性为O(n^2)。

for (i=5; i<n/2; i+=5) 
{
 for (j=1; j<n; j*=4)
      op;

 x = 3*n;
 while(x > 6) 
      {op;  x--;}
}

请注意，以下算法的复杂度为O(n^2*log(n))，与上述算法不同。

for (i=5; i<n/2; i+=5) 
{
 for (j=1; j<n; j*=4)
  {
   op;
   x = 3*n;
   while(x > 6) 
      {op;  x--;}
  }
}

如何计算算法的复杂性？

3 个答案: