Algorithm 为什么不包含N/2个步骤的代码被视为O（N）？

考虑一个嵌套循环。外部循环从

i=0

开始并迭代

N次

，内部循环从

j=i+1开始并迭代到
j=N
。因此，内部循环将大致执行n/2步。然而，在最后，运行时被认为是O（N2）为什么内部循环被认为是
O（N）
而不是
O（N/2）
，因为我们有其他具有O（log N）运行时的代码？
表示执行一段代码所需的时间复杂性，与某些度量成比例。通常，大括号中使用的符号表示输入大小、容器大小等数量

直观地说，
O（N）
是指代码运行的次数与大括号中包含的符号成比例，而不是它运行的确切次数。实际上，它可能运行
K=N/2次，但Big-O符号试图强调的一点是，
K
的值是由
N
的大小来估计的，并且它与
K
成正比

为了进一步澄清，请注意，对于足够大的N，除以2实际上并不重要，因为它只是一个常数因子。对于足够大的N，常数可以忽略的概念对于理解各种复杂度符号（包括Big-O）至关重要。
表示执行一段代码所需时间的复杂性，与某些度量成比例。通常，大括号中使用的符号表示输入大小、容器大小等数量

直观地说，
O（N）
是指代码运行的次数与大括号中包含的符号成比例，而不是它运行的确切次数。实际上，它可能运行
K=N/2次，但Big-O符号试图强调的一点是，
K
的值是由
N
的大小来估计的，并且它与
K
成正比

为了进一步澄清，请注意，对于足够大的N，除以2实际上并不重要，因为它只是一个常数因子。对于足够大的N，常数可以忽略的概念对于理解各种复杂度符号（包括Big-O）来说至关重要。
似乎您混合了两种不同的情况（在最终公式中的除法-
N**2/C
，其中
C
可以忽略：
O（N**2/C）=O（N**2）循环中的除法：
表示（int j=N；j>=1；j/=C）
其中
C
表示对数）：

所以我们有

(N - 1) + (N - 2) + ... + 2 + 1 + 0 ==
 N * (N - 1) / 2 == 
 N**2 / 2 - N / 2 ==
 O(N**2 / 2 - N / 2) == O(N**2 / 2) == O(N**2)

相反（请注意
j/=2
而不是
++j
），这意味着内部循环要少得多

 for (int i = 1; i <= N; ++i)
   for (int j = N; j >= 1; j /= 2) 
     SomeOperation(i, j);

 i    j
-------------------
 1    log(N)
 2    log(N)
 3    log(N)
..
 N    log(N)

似乎你混合了两种不同的情况（在最后的公式中除法-
N**2/C
，其中
C
可以忽略：
O（N**2/C）==O（N**2）
；循环中除法：
for（int j=N；j>=1；j/=C）
其中
C
导致对数）：

所以我们有

(N - 1) + (N - 2) + ... + 2 + 1 + 0 ==
 N * (N - 1) / 2 == 
 N**2 / 2 - N / 2 ==
 O(N**2 / 2 - N / 2) == O(N**2 / 2) == O(N**2)

相反（请注意
j/=2
而不是
++j
），这意味着内部循环要少得多

 for (int i = 1; i <= N; ++i)
   for (int j = N; j >= 1; j /= 2) 
     SomeOperation(i, j);

 i    j
-------------------
 1    log(N)
 2    log(N)
 3    log(N)
..
 N    log(N)

O（N）=C*O（N）
其中
C
是一个常数（
C==1/2
，在你的例子中），那么为什么在O（logn）情况下不是这样呢？O（N）和O（N/2）是完全相同的。O（N）的时间复杂度意味着运行时间随N加上负一些低阶手工操作线性增加；如果时间随N线性增加，它也随N/2线性增加，反之亦然。这都是关于。因此，可以省略常量。你的日志让我觉得你误解了什么，但很难说。例如，O（log_2n）与O（log_10n）相同（因为它只是一个常数）。
O（n）==C*O（n）
其中
C
是一个常数（
C==1/2
），那么为什么O（log n）的情况不是这样呢？O（n）和O（n/2）是完全相同的。O（N）的时间复杂度意味着运行时间随N加上负一些低阶手工操作线性增加；如果时间随N线性增加，它也随N/2线性增加，反之亦然。这都是关于。因此，可以省略常量。你的日志让我觉得你误解了什么，但很难说。例如，O（log_2n）与O（log_10n）相同（因为它只是一个常数）。
 log(N) + log(N) + ... + log(N) ==
 N * log(N) == 
 O(N * log(N))