Algorithm 理解大o符号

我有一个关于计算以下代码的大o符号的问题：

j = 1;
while ( j <= n ) do  
  for i = 1 to j do 
    O(1); 
  endfor; 
  j=j*2; 
endwhile

j=1；
而（j几何序列是正确的。举个简单的例子。如果n是8，则内部循环的迭代次数是1，然后是2，然后是4，然后是8。如果n是7，则有1，2，4，没有8。因此，随着n的增加，O（1）运算的次数将在n和2n-1之间变化。在该范围的任一侧，顺序是O（n）.
它在这里不是高斯的，因为它是一个几何序列

一旦j达到n，外部while回路将停止

所需的迭代次数可以通过取
log来计算₂（n） 
因为这里要解决的是一个问题
2^x=n
（我们需要不断乘以2多少次才能达到n）

有趣的是，这导致：

log₂(n)     log₂(n)
∑ 2^i    =  2       - 1 = n - 1
0

从1到log2（n）的求和接管了2^i
，这正是
2^（log2n）-1
=
n-1
（如果您的字体集不支持所需的unicode字符，请重复上面给出的公式）

利用这里的事实

k            k+1
∑ 2^i    =  2   - 1
0

因此，算法应该是O（n）

或者，您可以使用通用公式计算几何序列的总和：

Sn = a0 * (1-q^n) / (1-q)

这将导致与实际情况相同的结果：

        log₂n
   1 - 2           1 - n
  -----------  =  ------ = n - 1
    1 - 2           -1

这里它不是高斯的，因为它是一个几何序列，正如你已经提到的

一旦j达到n，外部while回路将停止

所需的迭代次数可以通过取
log来计算₂（n） 
因为这里要解决的是一个问题
2^x=n
（我们需要不断乘以2多少次才能达到n）

有趣的是，这导致：

log₂(n)     log₂(n)
∑ 2^i    =  2       - 1 = n - 1
0

从1到log2（n）的求和接管了2^i
，这正是
2^（log2n）-1
=
n-1
（如果您的字体集不支持所需的unicode字符，请重复上面给出的公式）

利用这里的事实

k            k+1
∑ 2^i    =  2   - 1
0

因此，算法应该是O（n）

或者，您可以使用通用公式计算几何序列的总和：

Sn = a0 * (1-q^n) / (1-q)

这将导致与实际情况相同的结果：

        log₂n
   1 - 2           1 - n
  -----------  =  ------ = n - 1
    1 - 2           -1

好吧！让我们假设一些值来帮助更好地理解：

设n等于4

So now:
j=1 ( <4 ) => loop runs 1 time = O(1)
j=1*2 = 2 ( <4 ) => loop runs 2 times = 2*O(1)
j=2*2 = 4 ( =4 ) => loop runs 4 times = 4*O(1)

那么现在：
j=1（循环运行1次=O（1）
j=1*2=2（循环运行2次=2*O（1）
j=2*2=4（=4）=>循环运行4次=4*O（1）

如果n的类型为2^x，则可以安全地说，循环运行的系列如下所示：

O（1）+2*O（1）+4*O（1）+8*O（1）+16*O（1）+……+n*O（1）。=1*（2^（x+1）-1）*O（1）/（2-1）
=（2n-1）*O（1）=O（n）
其中n=2^x，外部循环运行x+1次

现在，如果n不是2^x的类型，我们假设n=6

So now:
j=1 ( <6 ) => loop runs 1 time = O(1)
j=1*2 = 2 ( <6 ) => loop runs 2 times = 2*O(1)
j=2*2 = 4 ( <6 ) => loop runs 4 times = 4*O(1)
j=2*4 = 8 ( >6 ) => loop exits.

那么现在：
j=1（循环运行1次=O（1）
j=1*2=2（循环运行2次=2*O（1）
j=2*2=4（循环运行4次=4*O（1）
j=2*4=8（>6）=>循环出口。

很明显，外部循环将只运行2^（下限值（对数基数2（n）））+1次。这个值将是有效的n

让我们把它放到公式中：（2n-1）O（1）
=>（2（2^（floorValue（logBase2（n）））-1）*O（1）大约等于O（n）
好！让我们假设一些值以帮助更好地理解：

设n等于4

So now:
j=1 ( <4 ) => loop runs 1 time = O(1)
j=1*2 = 2 ( <4 ) => loop runs 2 times = 2*O(1)
j=2*2 = 4 ( =4 ) => loop runs 4 times = 4*O(1)

那么现在：
j=1（循环运行1次=O（1）
j=1*2=2（循环运行2次=2*O（1）
j=2*2=4（=4）=>循环运行4次=4*O（1）

如果n的类型为2^x，则可以安全地说，循环运行的系列如下所示：

O（1）+2*O（1）+4*O（1）+8*O（1）+16*O（1）+……+n*O（1）。=1*（2^（x+1）-1）*O（1）/（2-1）
=（2n-1）*O（1）=O（n）
其中n=2^x，外部循环运行x+1次

现在，如果n不是2^x的类型，我们假设n=6

So now:
j=1 ( <6 ) => loop runs 1 time = O(1)
j=1*2 = 2 ( <6 ) => loop runs 2 times = 2*O(1)
j=2*2 = 4 ( <6 ) => loop runs 4 times = 4*O(1)
j=2*4 = 8 ( >6 ) => loop exits.

那么现在：
j=1（循环运行1次=O（1）
j=1*2=2（循环运行2次=2*O（1）
j=2*2=4（循环运行4次=4*O（1）
j=2*4=8（>6）=>循环出口。

很明显，外部循环将只运行2^（下限值（对数基数2（n）））+1次。这个值将是有效的n

让我们把它放到公式中：（2n-1）O（1）
=>（2（2^（floorValue（logBase2（n）））-1）*O（1）大约等于O（n）
在这里做个小聪明：你要求的实际上是
Theta
。你的代码是
Theta（n）
，但也
O（n）
，
O（n*log\u 2（n））
甚至
O（n！）因为Big-O只是一个上界。
Theta
是精确的。
在这里要聪明一点：你要求的实际上是
Theta
。你的代码是
Theta（n）
-但也
O（n）
，
O（n*log\u2（n））
甚至
O（n！）
因为Big-O只是一个上界。
θ是精确的。
它应该是0（n^2）。
这与插入排序相同

void insertionsort(void){

 for(int x=1;x<n;x++){
   int temp= array[x];
   for(int y=x-1;  y>=0 && array[y]>temp ;y--){
    array[y+1]=array[y];
   }array[y+1]=temp;
 }
}

void insertionsort（void）{
对于（int x=1；x=0&&array[y]>temp；y--）{
数组[y+1]=数组[y]；
}阵列[y+1]=温度；
}
}

O（n）从1到n，但对于每一个，它从y=x-1到0。
在最坏的情况下，它总是从y=x-1变为0。所以每次x增长，它都会增长

你的一个就是这样。
它应该是0（n^2）。
这与插入排序相同

void insertionsort(void){

 for(int x=1;x<n;x++){
   int temp= array[x];
   for(int y=x-1;  y>=0 && array[y]>temp ;y--){
    array[y+1]=array[y];
   }array[y+1]=temp;
 }
}

void insertionsort（void）{
对于（int x=1；x=0&&array[y]>temp；y--）{
数组[y+1]=数组[y]；
}阵列[y+1]=温度；
}
}

O（n）从1到n，但对于每一个，它从y=x-1到0。
在最坏的情况下，它将永远