Algorithm 这两个伪算法的执行时间不同吗？ //-算法A INTA=1，b=2； 对于（int n=0；n

我是否应该尝试使用现有的循环进行必要的操作？还是最终结果是一样的

第一种算法肯定会更快，但由于复杂性只是线性增加，第二种算法也不错。只要你不去，两者都很好

---

但是如果你最终写了n个这样的循环，那么你就有了n^2的复杂度，这是不好的

第一个算法肯定会更快，但是由于复杂度只是线性增加，第二个算法也不错。只要你不去，两者都很好

但是如果你最终写了n个这样的循环，那么你就有了n^2的复杂性，这在O（n）表示法中是很糟糕的，它们是一样的。根据：

您将有一个总数：

// -- Algorithm A
    int a = 1, b = 2;
    for (int n = 0; n < 100; n++)
    {
        int c = a + b + n;
        int d = a - b - n;
    }

// -- Algorithm B
    int a = 1, b = 2;
    for (int n = 0; n < 100; n++)
    {
        int c = a + b + n;
    }

    for (int n = 0; n < 100; n++)
    {
        int d = a - b - n;
    }

O(n) + O(n) = O(2n)

然后乘以常数：

// -- Algorithm A
    int a = 1, b = 2;
    for (int n = 0; n < 100; n++)
    {
        int c = a + b + n;
        int d = a - b - n;
    }

// -- Algorithm B
    int a = 1, b = 2;
    for (int n = 0; n < 100; n++)
    {
        int c = a + b + n;
    }

    for (int n = 0; n < 100; n++)
    {
        int d = a - b - n;
    }

O(n) + O(n) = O(2n)

因此，最终将是O（n）

在O（n）符号中，它们将是相同的。根据：

您将有一个总数：

// -- Algorithm A
    int a = 1, b = 2;
    for (int n = 0; n < 100; n++)
    {
        int c = a + b + n;
        int d = a - b - n;
    }

// -- Algorithm B
    int a = 1, b = 2;
    for (int n = 0; n < 100; n++)
    {
        int c = a + b + n;
    }

    for (int n = 0; n < 100; n++)
    {
        int d = a - b - n;
    }

O(n) + O(n) = O(2n)

然后乘以常数：

// -- Algorithm A
    int a = 1, b = 2;
    for (int n = 0; n < 100; n++)
    {
        int c = a + b + n;
        int d = a - b - n;
    }

// -- Algorithm B
    int a = 1, b = 2;
    for (int n = 0; n < 100; n++)
    {
        int c = a + b + n;
    }

    for (int n = 0; n < 100; n++)
    {
        int d = a - b - n;
    }

O(n) + O(n) = O(2n)

---

因此，从复杂性的角度来看，最终将是O（n）

两种算法都是O（n）。即使你考虑乘法常数，你可以说一个是n* 2，另一个是n+n，这完全一样。

---

但事实上，这要视情况而定。有人可能会说，由于第二种算法执行的分支数是第二种算法的两倍，因此性能可能会更差（），但最终取决于编译器、特定输入、操作系统等。

就复杂性而言，这两种算法都是O（n）。即使你考虑乘法常数，你可以说一个是n* 2，另一个是n+n，这完全一样。

---

但事实上，这要视情况而定。有人可能会说，由于第二个执行的分支数量是原来的两倍，因此性能可能会更差（），但最终取决于当前实现中的编译器、特定输入、操作系统等。

O(2n) = O(n)

对

 for (int n = 0; n < N; n++)
 { 
   f(n);
   g(n);
 }

在第二种情况下

 T = f(0) + g(0) + 
     f(1) + g(1) + 
     ...  
     f(N - 2) + g(N - 2) +
     f(N - 1) + g(N - 1) 

如您所见，执行时间是相同的（不仅是

O（…）

）。 在现实生活中，两种实现之间的差异可能很小：

---

循环初始化和实现详细信息、CPU寄存器利用率等。

在当前实现中

O(2n) = O(n)

对

 for (int n = 0; n < N; n++)
 { 
   f(n);
   g(n);
 }

在第二种情况下

 T = f(0) + g(0) + 
     f(1) + g(1) + 
     ...  
     f(N - 2) + g(N - 2) +
     f(N - 1) + g(N - 1) 

如您所见，执行时间是相同的（不仅是

O（…）

）。 在现实生活中，两种实现之间的差异可能很小：

---

循环初始化和实现细节、CPU寄存器利用率等。

执行时间的差异必须很小（如果有），并且取决于编译器和优化理论或实践？聪明的编译器可以发现这两种算法都没有任何可观察到的结果，并将它们编译为不可操作。执行时间的差异必须很小（如果有的话），并且取决于编译器和优化理论或实践？一个聪明的编译器可以发现这两种算法都没有任何可观察到的结果，并将它们编译为不可操作。但我不明白的是：在算法B中，n++指令的执行次数不是要两次吗？复杂性怎么可能是相同的？O（n）是近似值。它通过函数来描述时间复杂度。在这种情况下，两种实现都是线性函数，它们被视为线性函数的组合，因此最终它们都是O（n）。O（n）不是用来计算函数需要多长时间，而是用来估计范围。但我不能理解的是：在算法B中，n++指令执行的次数不是两次吗？复杂性怎么可能是相同的？O（n）是近似值。它通过函数来描述时间复杂度。在这种情况下，两种实现都是线性函数，它们被视为线性函数的组合，因此最终它们都是O（n）。O（n）不是用来计算函数需要多长时间，而是用来估计范围。@PedroBatista两个操作（

a+b+n

和

a-b-n

）中的每一个都将执行一百次，但与循环相关的操作原则上在第二个版本中运行的次数是第一个版本的两倍。这基本上包括计数器的增量和比较（可以认为是不重要的）以及跳回到循环开始处的分支指令（可能不是不重要的）。但是，复杂性是相同的，因为它没有考虑乘法常数（这就是为什么它会误导很多次）. 因此，即使其中一个花费的时间是另一个的10倍，只要它始终是10的一个因子（而不是m，或者m的大小，其中m是一些输入），复杂性是相同的。好的，我明白了。因此，n++和比较将出现两次（除非智能编译器实现这一点并优化我的哑代码）@PedroBatista两个操作（

a+b+n

和

a-b-n

）中的每一个都将执行一百次，但与循环相关的操作原则上是，在第二个版本中运行的次数是第一个版本的两倍。这基本上包括计数器的增量和比较（可以认为是不重要的）以及跳回到循环开始处的分支指令（可能不是不重要的）。但是，复杂性是相同的，因为它没有考虑乘法常数（这就是为什么它会误导很多次）. 因此，即使其中一个花费的时间是另一个的10倍，只要它始终是10的一个因子（而不是m，或者m的大小，其中m是一些输入），复杂性是相同的。好的，我明白了。所以n++a