这些嵌套循环的大O.

Question

我对Big-O领域很陌生，所以请耐心等待。我一直在寻找它，但我仍然需要做很多工作才能完全理解它 我在练习中遇到了这些嵌套for循环，没有任何解决方案，它们看起来很复杂。所以，任何帮助将不胜感激。

1）

int sum=0;
for(int i=0; i < n^2; i++) { // n+1
    for(int j = n-1; j >= n-1-i; j–-) { // n(n+1)/2 ?
        sum = i+j; // n(n+1)/2 ?
        System.out.println(sum); // n(n+1)/2 ?
    }
}

Big-O =？

2）

int sum=0;
for(int i=1; i <= 2^n; i=i*2) { // log(n)
    for(int j=0; j <= log(i); j++) { // log(n(n+1)/2) ?
        sum = i+j; // log(n(n+1)/2) ?
        System.out.println(sum); // log(n(n+1)/2) ?
    }
}

Big-O =？

3）

int sum = 0; int k = 23;
for(int i=k; i <= 2^(n−k); i=i*2) { // log(n)
    for(int j=2^(i−k); j < 2^(i+k); j=j*2) { // log(log(n)) ?
        sum = i+j; // log(log(n)) ?
        System.out.println(sum); // log(log(n)) ?
    }
}

Big-O =？

4）

int sum=0;
for(int i=2n; i>=1; i=i/2) {
    for(int j=i; j>=1; j=j/2) {
        sum = i+j;
        System.out.println(sum);
    }
}

Big-O =？

---

修改
- 更正了＃4。对不起，这很麻烦。
- 日志的基础是2.
- 这里的 ^ 表示＆＃34;对电源＆＃34;而不是xor。

Answer 1

有很多问题，例如"Big-O of nested loops" here on stackoverflow（和答案）。

但是，你会得到我的回答。但首先是一个符号问题： 您将此问题标记为java。在代码中，我看到2ⁿ或n²之类的内容。在java this means xor，但我认为你的意思是Math.pow(2,n)，所以对于这个答案，我会将其视为权力运算符。

1. int sum=0;
   for(int i=0; i < n^2; i++) {             // outer loop
       for(int j = n-1; j >= n-1-i; j–-) {  // inner loop
           sum = i+j;                       // inner operations
           System.out.println(sum);
       }
   }
   

   内部操作在O(1)中运行，因此我只计算它们被调用的频率。

   • 外部循环运行n²次。
   • 对于每个i（来自外部循环），内部循环运行i次。

   总共得到0+1+...+(n²-1)+n² = n²(n²+1)/2。这是Θ(n⁴)。

2. int sum=0;
   for(int i=1; i <= 2^n; i=i*2) {           // outer loop
       for(int j=0; j <= log(i); j++) {      // inner loop
           sum = i+j;                        // inner operations
           System.out.println(sum); 
       }
   }
   

   • 外部循环运行n次，因为2⋅2⋅2⋅...⋅2（n次）等于2 ⁿ 。
   • 假设对数的底数为2，内部循环对每个i = 2 ^k （1≤k≤n）运行k次。

   总共得到1+2+3+...+n-1+n = n(n+1)/2。这是Θ(n²)。

3. int sum = 0; int k = 23;
   for(int i=k; i <= 2^(n−k); i=i*2) {          // outer loop
       for(int j=2^(i−k); j < 2^(i+k); j=j*2) { // inner loop
           sum = i+j;                           // inner operations 
           System.out.println(sum);             
       }
   }
   

   • 外部循环运行m次，m最小，k⋅2m > 2n-k成立。这可以写成k⋅2k⋅2m > 2n。 k必须是positiv（否则外循环将永远运行）。假设k受O(n)限制（空格也在O(n)），m也受O(n)限制。
   • 无论2⋅k或i是什么，内部循环始终会n次运行。这是O(1) k O(n) k O(n)为O(n)。

   对于k中的O(n²)，k O(n)和int sum=0; for(int i=2n; i>=1; i=i/2) { // outer loop for(int j=i; j>=1; j=j/2) { // inner loop sum = i+j; // inner operations System.out.println(sum); } } 总共获得log(n)。

4. j

   • 外部循环运行1次，就像案例2（反过来）
   一样
   • 内部循环运行2n次（基本上）n = 2k和log(n) = k之间的每个2的幂。

   假设2k+1+2k+2k-1+...+22+21+20=2k+2-1=4n-1（表示O(n)），你总得到了 {{1}}。所以这在{{1}}中。这也适用于n而不是2的幂。

Answer 2

使用Sigma表示法有条不紊地为您的迭代算法寻找解决方案：

---

使用base 2作为下面的日志：

---

---