Python 了解如何度量函数的时间复杂度

这就是功能：

c = []
def badsort(l):
  v = 0
  m = len(l)
  while v<m:
    c.append(min(l))
    l.remove(min(l))
    v+=1
  return c

c=[]
def badsort（左）：
v=0
m=len（l）
而v这个问题的时间紧迫性是O（n^2）

。虽然代码本身只有一个明显的循环，

While

循环、

min

和

max

函数通过实现都是

O（n）

，因为在最坏的情况下，它必须扫描整个列表以找到相应的最小值或最大值<代码>列表。删除是

O（n）

，因为它也必须遍历列表，直到找到第一个目标值，最坏的情况下，可能是在末尾<代码>列表.append是摊销的

O（1）

，这是由于该方法的巧妙实现，因为

list.append

在技术上是

O（n）/n=O（1）

用于推送的

n

对象：

def badsort(l):
  v = 0
  m = len(l)
  while v<m: #O(n)
    c.append(min(l)) #O(n) + O(1) 
    l.remove(min(l)) #O(n) + O(n)
    v+=1
  return c

---

O（n）+O（n）+O（n）

可以简单地组合成

O（n）

，因为大O度量最坏情况。因此，通过结合外部和内部的复杂性，最终的复杂性是

O（n^2）

以下是一些有用的要点，可以帮助您了解如何找到函数的复杂性

测量迭代次数

在每次迭代中测量每个操作的复杂性

对于第一点，您可以看到终止条件是

v

，其中

v

最初是0，而

m

是列表的大小。由于

v

在每次迭代中递增一次，因此循环最多（至少）运行

N

次，其中

N

是列表的大小

现在，关于第二点。每次迭代，我们有-

c.append(min(l))

其中

min

是一个线性运算，取

O（N）

时间<代码>追加是一个常量操作

其次,

l.remove(min(l))

同样，

min

是线性的，

remove

也是线性的。所以，你有

O（N）

+

O（N）

，这就是

O（N）

总之，您有

O（N）

迭代，并且每次迭代都有

O（N）

，使其成为

O（N**2）

，或二次。

术语 假设

n=len（l）

迭代计数 外部循环运行n次。内部循环中的

min（）

在l上运行两次（此处有优化的空间），但对于递增递减的数字（对于循环的每次迭代，l的长度递减，因为每次都从列表中删除一项）

这样，复杂性是

2*（n+（n-1）+（n-2）+…+（n-n））

。 这等于

2*（n^2-（1+2+3+…+n））

。 括号中的第二项是a，并发散到

n*（n+1）/2

因此，您的复杂性等于

2*（n^2-n*（n+1）/2））

。 这可以扩展到

2*（n^2-n^2/2-n/2）

， 并简化为

n^2-n

比戈符号 BigO表示法关注的是整体增长趋势，而不是函数的精确增长率

下降常数 在BigO表示法中，常量被删除。因为没有常数，所以我们仍然有

n^2-n

只保留主要条款 此外，在BigO符号中，只考虑主导项

n^2

在

n

上占主导地位，因此

n

被删除

结果

---

这意味着BigO中的答案是

O（n）=n^2，即二次复杂度
 如果它说“坏”，它几乎总是二次的或更糟的。你应该解释为什么这些线是O（N），以及具体的原因。在最后一行中，你提到了最后的复杂性是O（N），但在第一行中，你提到了O（N^2）。总体时间复杂度是多少？好的。那太好了。谢谢@Cᴏʟᴅsᴘᴇᴇᴅ 这将具体解释
min
、
max
、
remove
和
append
的实现，我认为这超出了问题的范围。你不应该增加内部和外部的时间复杂度，而不是增加它们吗？@RoadRunner Politics、复仇投票等。天空是极限；-）
l.remove(min(l))