O（logn）指的是一个函数（或算法，或算法中的步骤），其工作时间与输入大小的对数成正比（大多数情况下通常以2为基数，但并不总是以2为底，在任何情况下，通过big-O符号*，这都是无关紧要的）。

对数函数是指数函数的倒数。换句话说，如果您的输入呈指数增长（而不是通常认为的线性增长），则函数呈线性增长。

O（logn）运行时间在任何一种分而治之的应用程序中都很常见，因为（理想情况下）每次都会将工作减半。如果在每一个除法或征服步骤中，你都在做恒定时间的工作（或不是恒定时间的，但随着时间的增长比O（log n）慢），那么你的整个函数就是O（log）。相当常见的是，每个步骤都需要输入线性时间；这将相当于O（n log n）的总时间复杂度。

二进制搜索的运行时间复杂性是O（logn）的一个例子。这是因为在二进制搜索中，通过将数组分成两半，并且每一步只关注一半，您总是忽略后面每一步的一半输入。每一步都是恒定的时间，因为在二进制搜索中，您只需要将一个元素与关键字进行比较，就可以确定下一步要做什么，而不管您考虑的数组在任何时候都有多大。因此，大约执行log（n）/log（2）步。

合并排序的运行时间复杂性是O（n log n）的一个例子。这是因为每一步都将阵列一分为二，总共约为log（n）/log（2）步。然而，在每一步中，您都需要对所有元素执行合并操作（无论是对n/2个元素的两个子列表执行一次合并操作，还是对n/4个元素的四个子列表执行两次合并操作都是无关紧要的，因为这增加了每一步对n个元素执行合并的必要性）。因此，总复杂度为O（n log n）。

*记住，根据定义，big-O表示法并不重要。同样，通过改变对数的基数规则，不同基数的对数之间的唯一差异是一个常数因子。

概述

其他人已经给出了很好的图表示例，例如树形图。我没有看到任何简单的代码示例。因此，除了我的解释，我还将提供一些带有简单打印语句的算法，以说明不同算法类别的复杂性。

首先，你需要对对数有一个大致的了解，你可以从https://en.wikipedia.org/wiki/Logarithm . 自然科学使用e和自然日志。工程弟子将使用log_10（对数基数10），计算机科学家将大量使用log_2（对数基数2），因为计算机是基于二进制的。有时你会看到自然log的缩写为ln（），工程师通常不使用_10，只使用log（），log_2缩写为lg（）。所有类型的对数都以类似的方式增长，这就是为什么它们共享相同的log（n）类别。

当您查看下面的代码示例时，我建议您先查看O（1），然后查看O（n），然后再查看O（n^2）。在你擅长这些之后，再看看其他的。我已经包含了干净的示例和变体，以证明细微的变化仍然可以导致相同的分类。

你可以把O（1）、O（n）、O（logn）等看作是增长的类或类别。有些类别要比其他类别花费更多的时间。这些类别有助于我们对算法性能进行排序。有些随着输入n的增长而增长得更快。下表以数字形式显示了上述增长。在下表中，将log（n）视为log_2的上限。

各种大O类别的简单代码示例：

O（1）-恒定时间示例：

算法1：

算法1打印一次hello，它不依赖于n，所以它总是在恒定的时间内运行，所以它是O（1）。

print "hello";

算法2：

算法2打印hello 3次，但它不取决于输入大小。即使随着n的增长，该算法也将始终只打印hello 3次。也就是说，3是一个常数，所以这个算法也是O（1）。

print "hello";
print "hello";
print "hello";

O（log（n））-对数示例：

算法3-其行为类似于“log_2”

算法3演示了在log_2（n）中运行的算法。注意for循环的后操作将i的当前值乘以2，因此i从1到2到4到8到16到32。。。

for(int i = 1; i <= n; i = i * 2)
  print "hello";

算法4-其行为类似于“log_3”

算法4证明了log_3。注意我从1到3到9到27。。。

for(int i = 1; i <= n; i = i * 3)
  print "hello";

算法5-其行为类似于“log_1.02”

算法5很重要，因为它有助于表明，只要数字大于1，并且结果与自身重复相乘，那么你就在看对数算法。

for(double i = 1; i < n; i = i * 1.02)
  print "hello";

O（n）-线性时间示例：

算法6

这个算法很简单，可以打印n次hello。

for(int i = 0; i < n; i++)
  print "hello";

算法7

该算法显示了一种变体，它将打印hello n/2次。n/2=1/2*n。我们忽略1/2常数，看到这个算法是O（n）。

for(int i = 0; i < n; i = i + 2)
  print "hello";

O（n*log（n））-log（n）示例：

算法8

将其视为O（log（n））和O（n）的组合。for循环的嵌套帮助我们获得O（n*log（n））

for(int i = 0; i < n; i++)
  for(int j = 1; j < n; j = j * 2)
    print "hello";

算法9

算法9类似于算法8，但每个循环都允许变化，这仍然导致最终结果为O（n*log（n））

for(int i = 0; i < n; i = i + 2)
  for(int j = 1; j < n; j = j * 3)
    print "hello";

O（n^2）-n平方示例：

算法10

O（n^2）很容易通过循环的嵌套标准获得。

for(int i = 0; i < n; i++)
  for(int j = 0; j < n; j++)
    print "hello";

算法11

类似于算法10，但有一些变化。

for(int i = 0; i < n; i++)
  for(int j = 0; j < n; j = j + 2)
    print "hello";

O（n^3）-n立方示例：

算法12

这类似于算法10，但有3个循环而不是2个。

for(int i = 0; i < n; i++)
  for(int j = 0; j < n; j++)
    for(int k = 0; k < n; k++)
      print "hello";

算法13

类似于算法12，但具有一些仍然产生O（n^3）的变化。

for(int i = 0; i < n; i++)
  for(int j = 0; j < n + 5; j = j + 2)
    for(int k = 0; k < n; k = k + 3)
      print "hello";

总结

上面给出了几个直接的例子和变化，以帮助说明可以引入哪些细微的变化，而这些变化实际上不会改变分析。希望它能给你足够的洞察力。

我无法理解如何使用日志时间标识函数。

对数运行时间函数最常见的属性是：

选择下一个要执行某些操作的元素是多种可能性之一，并且只需要选择一个。

or

执行操作的元素是n的数字

这就是为什么，例如，在电话簿中查找人是O（logn）。你不需要检查电话簿上的每个人，就能找到合适的人；相反，你可以简单地根据他们的名字的字母顺序进行划分和征服，在每个部分中，你只需要探索每个部分的一个子集，就可以最终找到某人的电话号码。

当然，一本更大的电话簿仍然需要更长的时间，但它的增长速度不会像增加电话簿的比例那样快。

---

我们可以扩展电话簿示例，以比较其他类型的操作及其运行时间。我们将假设我们的电话簿中有具有唯一名称的业务（“黄页”）和可能没有唯一名称的人员（“白页”）。电话号码最多分配给一个人或一家公司。我们还将假设翻到特定页面需要恒定的时间。

以下是我们可能在电话簿上执行的一些操作的运行时间，从最快到最慢：

O（1）（在最坏的情况下）：给定企业名称所在的页面和企业名称，找到电话号码。O（1）（在一般情况下）：给定一个人的名字和他们的名字所在的页面，找到电话号码。O（log n）：给定一个人的名字，在书中你还没有搜索到的部分的中途随机抽取一个点，然后检查这个人的名字是否在这个点上，从而找到电话号码。然后在书中人名所在的部分重复这个过程。（这是对人名的二进制搜索。）O（n）：查找电话号码包含数字“5”的所有人。O（n）：给定一个电话号码，找到拥有该号码的人或企业。O（n log n）：打印机的办公室出现了混乱，我们的电话簿上的所有页面都以随机顺序插入。通过查看每一页上的名字，然后将该页放在新的空电话簿中的适当位置，修正顺序，使其正确。

对于以下示例，我们现在在打印机的办公室。电话簿等待邮寄给每位居民或企业，每个电话簿上都有一个标签，标明应该邮寄到哪里。每个人或企业都有一本电话簿。

O（n log n）：我们想让电话簿个性化，所以我们将在他们指定的副本中找到每个人或企业的名字，然后在电话簿中圈出他们的名字，并为他们的惠顾写一封简短的感谢信。O（n2）：办公室发生了一个错误，每个电话簿中的每个条目在电话号码末尾都有一个额外的“0”。取出一些白色，去掉每个零。O（n·n！）：我们准备好把电话簿装到码头上了。不幸的是，原本要装书的机器人已经失控了：它正在把书按随机顺序放在卡车上！更糟糕的是，它把所有的书都装到卡车上，然后检查它们的顺序是否正确，如果不正确，它就把它们卸下来，重新开始。（这是可怕的bogo类型。）O（nn）：你把机器人修好，这样它就能正确地装载东西。第二天，你的一个同事对你开了个玩笑，把装卸台机器人连接到自动打印系统上。每次机器人去装载一本原版书时，工厂打印机都会对所有的电话簿进行重复打印！幸运的是，机器人的错误检测系统足够复杂，当它遇到要加载的复制书时，它不会尝试打印更多的副本，但它仍然必须加载已打印的每一本原始和复制书。

完整的二进制示例是O（ln n），因为搜索结果如下：

1 2 3 4 5 6 7 8 9 10 11 12

搜索4个会产生3次命中：6次，3次，然后4次。而log2 12=3，这是一个很好的近似值，以多少命中需要。

下面的解释是使用完全平衡的二叉树来帮助您理解我们如何获得对数时间复杂度。

二叉树是一种情况，其中大小为n的问题被划分为大小为n/2的子问题，直到我们达到大小为1的问题：

这就是你如何得到O（logn），这是在上面的树上需要完成的工作量，以获得解决方案。

具有O（logn）时间复杂度的常见算法是二进制搜索，其递归关系为T（n/2）+O（1），即在树的每个后续级别上，您将问题分成一半，并执行恒定数量的额外工作。

实际上，如果您有一个n个元素的列表，并从该列表中创建一个二叉树（就像在除法和征服算法中一样），您将一直除以2，直到达到大小为1的列表（树叶）。

在第一步，你除以2。然后，您有2个列表（2^1），将每个列表除以2，因此您有4个列表（2*2），然后再进行一次除法，您有8个列表（3^3），依此类推，直到列表大小为1

这给出了一个等式：

n/（2^步）=1<=>n=2^步<=>lg（n）=步

（取每边的lg，lg为对数基数2）