Performance 两次单独循环和循环内循环之间的性能

单独循环两次和在一个循环内循环之间是否有性能差异？

---

如何证明或计算它？

它完全取决于循环。下面是运行时间的一些例子：

1) Nested loops to n

for(i from 1 to n){
    for(j from 1 to n){
        ...
    }
}

2) Nested loops to n with the inner loop starting from i

for(i from 1 to n){
    for(j from i to n){
        ...
    }
}

3) Second loop iterates n^2 times since i == n

for(i from 1 to n){
    ...
}
for(j from 1 to i*n){
    ...
}

4) One loop up to n*n/50

for(i from 1 to n*n/50){
    ...
}

下面是一些

O（n）

循环的示例：

1) Simple loop

for(i from 1 to n){
    ...
}

2) Nested loop with constant iterations

for(i from 1 to n){
    for(j from 1 to 5){
        ...
    }
}

然后，您会发现，对于足够小的

n

，如循环到

n*n/50

，更好的时间复杂性并不总是更快。如果

n

小于

8

（一个正整数），那么该循环根本不会迭代，因此它显然比简单的

O（n）

循环要快，后者将精确地迭代

n

次。

一般来说：

如果有两个不同长度的不同循环（

n

和

m

），那么它可能是

O（n+m）

---

你能给我们举一个例子来说明你的意思吗？一般来说，第一个是

O（n）

（线性时间），第二个是

O（n^2）

（二次时间）。根据你的描述，

O（2n）

和

O（n^2）

，请给出一些例子code@TomaszNurkiewicz同意，根据我之前的评论（但请记住，

O（2n）

是

O（n）

）。@MattBall：当然，我写

2n

只是为了强调我们有两个循环。有趣！我只是在想一些基本的问题。似乎循环可以变得更加有趣@Jerry我看到了你对这个问题的评论，你的两个简单循环之间的区别在于时间复杂性。并排的两个循环是

O（n）

，嵌套的两个循环是

O（n^2）

，这意味着存在一个特定的

n

，从这一点开始，并排循环总是花费较少的时间。如果我们假设循环的内容是相同的（并且忽略循环头），我们可以得到这种情况的确切答案：并行循环的内容精确执行

2n次，然后嵌套循环的内容精确执行
n^2次。所以我们可以求解n的方程。将两边除以
n
，得到
2=n
（或
n=2
）。因此当
n
为
2
时，两个循环的时间相同（4次迭代）。很容易看出，当
n
为
1
时，
n^1
的速度更快（1次迭代）。并排循环有2次迭代。当
n
为0时，它们都是0次迭代。但是当
n
大于
2
时，2个并排循环将减少迭代次数。假设
n
是10。然后，您将使用并排循环得到
20
迭代，而使用嵌套循环得到
100
。距离
2
越远的
n
距离越大。
for (int i = 0; i < n; i++) {}
for (int i = 0; i < m; i++) {}    

for (int i = 0; i < n; i++) {
   for (int j = 0; j < m; j++) {
   }
}