Algorithm 嵌套循环的大O表示法

我试图找出这段代码的时间复杂度

for (int i = 0; i <= n - 1; i++)
  for (int j = i + 1; j <= n - 1; j++)
    for (int k = j + 1; k <= n - 1; k++)

for（int i=0；i
现在这个循环的最大Oh是O（n^5）。我是正确的还是犯了一些错误

不，这是不正确的。时间复杂度是
O（n^3）

简单来说，你可以这样想：

在每个for循环中，从
0
开始到
n-1
的最大步数为
n
。因此，如果有两个循环，一个嵌套在另一个循环中，那么对于在外部循环中进行的每一步，都在嵌套循环中进行
n
步数。给定在外部循环中进行的步数为
n
，很明显，最后您将执行
n^2
步骤

基于上述内容，您可以在以下情况下轻松绘制：

for(int i=0; i<=n-1; i++)
{
    for(int j=0; j<=n-1; j++)
    {
        for(int k=0; k<=n-1; k++)
        {

        }
    }
}

for（int i=0；i
现在这个循环的最大Oh是O（n^5）。我是正确的还是犯了一些错误

不，这是不正确的。时间复杂度是
O（n^3）

简单来说，你可以这样想：

在每个for循环中，从
0
开始到
n-1
的最大步数为
n
。因此，如果有两个循环，一个嵌套在另一个循环中，那么对于在外部循环中进行的每一步，都在嵌套循环中进行
n
步数。给定在外部循环中进行的步数为
n
，很明显，最后您将执行
n^2
步骤

基于上述内容，您可以在以下情况下轻松绘制：

for(int i=0; i<=n-1; i++)
{
    for(int j=0; j<=n-1; j++)
    {
        for(int k=0; k<=n-1; k++)
        {

        }
    }
}

for（int i=0；i如果您有疑问，希望说服自己只需执行一个小测试：

#include <stdio.h>

int main()
{
int count1=0,count2=0;
int n=100;

for (int i = 0; i <= n - 1; i++)

for (int j = i + 1; j <= n - 1; j++)

for (int k = j + 1; k <= n - 1; k++)
  count1++;

for (int i = 1; i <= n; i++)

for (int j = 1; j <= n; j++)

for (int k = 1; k <= n; k++)
  count2++;

printf("count1 %d count2 %d n %d\n",count1,count2,n);
return 0;
}


很明显，第二个循环运行
100**3
times=>O（n**3）

由于边界的原因，第一个循环运行得更少，但它仍然是线性的（边界上没有除法运算）=>O（n**3），即使它更快

如果您有疑问，并且希望说服自己，只需执行一个小测试：

#include <stdio.h>

int main()
{
int count1=0,count2=0;
int n=100;

for (int i = 0; i <= n - 1; i++)

for (int j = i + 1; j <= n - 1; j++)

for (int k = j + 1; k <= n - 1; k++)
  count1++;

for (int i = 1; i <= n; i++)

for (int j = 1; j <= n; j++)

for (int k = 1; k <= n; k++)
  count2++;

printf("count1 %d count2 %d n %d\n",count1,count2,n);
return 0;
}


很明显，第二个循环运行
100**3
times=>O（n**3）

由于边界的原因，第一个循环运行得更少，但它仍然是线性的（边界上没有除法运算）=>O（n**3），即使它更快

这些循环是嵌套的吗？如果是这样的话，您可以这样重写循环，使事情更容易解释。虽然我会给每个循环指定一个不同的迭代器名称，以避免混淆：

for (int a = 1; a <= n; a++) {
    for (int b = 1; b <= n; b++) {
        for (int c = 1; c <= n; c++) {
            ...
        }
    }
}

for（int a=1；a这些循环是嵌套的吗？如果是这样的话，您可以这样重写循环，使事情更容易解释。虽然我会给每个循环指定不同的迭代器名称，以避免混淆：

for (int a = 1; a <= n; a++) {
    for (int b = 1; b <= n; b++) {
        for (int c = 1; c <= n; c++) {
            ...
        }
    }
}

for（int a=1；a添加计数器的代码的第一个变体：

int count = 0
for (int i = 0; i <= n - 1; i++)
    for (int j = i + 1; j <= n - 1; j++)
        for (int k = j + 1; k <= n - 1; k++)
            count++;

int count=0
对于（int i=0；i添加计数器的代码的第一个变体：

int count = 0
for (int i = 0; i <= n - 1; i++)
    for (int j = i + 1; j <= n - 1; j++)
        for (int k = j + 1; k <= n - 1; k++)
            count++;

int count=0
对于（int i=0；i“5”从何而来？同样，使用适当的缩进来显示它们是嵌套的。第一个循环运行n次。第二个循环运行n^2次…第三个循环运行n^3次，因为它们都是嵌套的。但有时我认为它的大O表示法是1+2+3=6，即O（n^6）请看下面trincot的解决方案。同样，这样想：你第二次化身的最内层循环需要O（n）步骤正确吗？当然，它被调用了很多次，但是最里面的循环，当你在那里的时候，只需要n个步骤。中间的循环调用最里面的循环n次。所以这需要最里面的循环所需的步骤的n倍，也就是O（n），所以第二个循环需要O（n^2）。最后，外部循环调用O（n^2）操作n次，因此总数将为O（n^3）。从何处获取“5”？此外，使用适当的缩进显示它们是嵌套的。第一个循环运行n次..第二个循环运行n^2次..第三个循环运行n^3次，因为它们都是嵌套的。但有时我认为它的大O表示法是1+2+3=6，即O（n^6）请看下面trincot的解决方案。同样，这样想：你第二次化身的最内层循环需要O（n）步骤正确吗？当然，它被调用了很多次，但是最里面的循环，当你在那里的时候，只需要n个步骤。中间的循环调用最里面的循环n次。所以这需要最里面的循环所需的步骤的n倍，也就是O（n），所以第二个循环需要O（n^2）。最后，外部循环调用O（n^2）操作n次，因此总数为O（n^3）。第一个循环运行n次。第二个循环运行n^2次…第三个循环运行n^3次，因为它们都是嵌套的。但有时我认为它的大O表示法是1+2+3=6，即O（n^6）@Knowledge32让我们根据我上面给出的示例来考虑它。让我们分离两个内部循环。这会运行多少次？显然，
n^2
。如果我们将一段复杂度为
n^2
的代码放入for语句中，其复杂度为
O（n）
，那么总的复杂度将是
O（n^3）
。为什么？正如我们之前看到的那样，你会执行n个步骤，因为在每一步中你都会执行
n^2
，最后你会执行
n*n^2
。所以
n^3
步骤。所以，如果你的内部循环有10条语句，那么复杂性是O（n^16）？来吧。每个人都在告诉你O（n^3）从一开始，@Knowledge32第一个循环运行n次..第二个循环运行n^2次..第三个循环运行n^3次，因为它们都是嵌套的。但有时我认为它的大O表示法是1+2+3=6，即O（n^6）@Knowledge32让我们根据我上面给出的示例来考虑它。让我们分离两个内部循环。这会运行多少次？显然，
n^2
。如果我们将一段复杂度为
n^2
的代码放入for语句中，其复杂度为
O（n）
，那么总的复杂度将是
O（n^3）
。为什么？正如我们之前看到的，您将执行n个步骤，因为在每个步骤中，您将执行
n^2
，然后在最后执行
n*