Algorithm 大O表示法——而循环+表示未指定范围的循环

如何找到此算法的大O符号

这就是我得到的：在+logn+1上，我对我的答案非常不确定，因为我只知道如何使用for循环找到时间复杂性。但是这个和我所知道的不同

对于for循环，我知道当给定一个范围时，可以使用求和来计算循环迭代的次数，但没有给定范围，只有索引

如果有人能帮我找到每行代码的总运行时间，我将不胜感激

Find Base(N,B)   // N>=1 and B>=2
    index <- 0
    while N > 0 do                              
       A[index] <- N % B         
       N <- N / B                         
       index <- index + 1              O(logn)     
    for j = 0 to index do                
       temp <- A[j]
       A[j] <- A[index – j]
       A[index – j] <- temp
return A

---

在回答这个问题之前，我要声明，这个答案中绝对没有数学上的严格性。有时候，你会遇到这样一个问题，你不能只看一些东西，并从中提取有用的运行时复杂性——这时你就不用管它了，转而使用实际的严格数学。对我们中的很多人来说，没有必要经常这么做

如果你想进行严格的数学分析，那就自己做吧

现在，让我们继续进行快速而肮脏的渐进运行时复杂性分析。我们基本上只是计算我们每件事做了多少

首先确定每个步骤需要多长时间，从最简单的操作开始。通常确定每个恒定时间操作

对于这个例子，我需要添加一个未声明的假设。随机存取用于读写的数据是恒定时间。显然，有一些数据结构会使这个假设失效，所以我们应该弄清楚这一点

Find Base(N,B)   // N>=1 and B>=2    
    index <- 0                       // O(1) - assign constant to a local
    while N > 0 do                              
       A[index] <- N % B             // O(1) - calculate division remainder,
                                     //        array random access write
       N <- N / B                    // O(1) - calculate integer division,
                                     //        assign to local
       index <- index + 1            // O(1) - addition,
                                     //        assign to local
    for j = 0 to index do                
       temp <- A[j]                  // O(1) - array random access read,
                                     //        assign to local
       A[j] <- A[index – j]          // O(1) - array random access read,
                                     // O(1)   array random access write
       A[index – j] <- temp          // O(1) - array random access write
return A

运行索引+1次，每次执行O1项操作。在每一步中，我们都可以将其转换为Big-O运行时。去掉所有常量因子和非显性项：这是Oindex。我们仍然需要计算出什么是N和B的指数，所以我们会记住这一点

第一圈

    while N > 0 do                              
       A[index] <- N % B         
       N <- N / B                         
       index <- index + 1

我们已经计算出整个环体是O1。现在我们需要知道它以N和B执行了多少次。首先确定是什么步骤导致它终止。对循环条件中使用的变量的赋值，以及对为该赋值计算的值作出贡献的任何内容都是相关的

这条线是n1到0不是负数。对于循环的每一次迭代，N都有值N，N/B，N/B^2等等，所以这是除以B，直到我们不能再除以。因此，当N/B^t<1时，循环将结束。当N Total runtime只是一个接一个运行的两个循环的总和：OlogN+Oindex

回到那个讨厌的指数。它从0开始，在第一个循环的每次迭代中递增1。我们确定该循环存在OlogN迭代。所以索引的值是OlogN。所以Oindex是OlogN。上一个和现在有一个我们可以忽略的常数因子，所以总数是OlogN

与我在这里详细介绍的情况相比，在你的头脑中浏览所有这些内容并草草记下重要部分的实际过程实际上非常快。不过，同样的基本方法通常也适用——只需仔细计算操作数

这里没有击中需要小心的东西。有时一个循环体每次迭代可以执行不同的数量，所以每次迭代的相加并不像这里的乘法那样简单。有时，你会从中得到线性或几何级数，你需要在快速而肮脏的分析过程中插入一点实际的数学知识

---

*对数基之间的转换就是常数因子的乘法。因为我们可以忽略Big-O中一个常数的乘法，所以对于所有的对数基，Ologn都是相同的。

观察：你可以忽略其中包含a的所有行，因为它们不会影响循环的运行次数。堆栈溢出不是一个为我做功课的站点。请描述您遇到的实际问题。到目前为止，您在尝试解决问题方面做了哪些工作，以及具体需要哪些帮助。您能否解释一下是什么过程导致您找到了当前建议的答案？当循环嵌套时，时间会成倍增加。但是本例中的循环并不是嵌套的，假设缩进是正确的，所以时间会增加。@user3386109 ohh我刚才注意到了。非常感谢。

    while N > 0 do                              
       A[index] <- N % B         
       N <- N / B                         
       index <- index + 1