python中求和时间复杂度最低的_python中各种操作的时间复杂度

以下的python操作的时间复杂度是Cpython解释器中的。其它的Python实现的可能和接下来的有稍微的不同。

一般来说,“n”是目前在容器的元素数量。 “k”是一个参数的值或参数中的元素的数量。

(1)列表：List

一般情况下，假设参数是随机生成的。

在内部，列表表示为数组。在内部，列表表示为数组。 最大的成本来自超出当前分配大小的范围(因为一切都必须移动)，或者来自在开始处附近插入或删除某处(因为之后的所有内容都必须移动)。 如果需要在两端添加/删除，请考虑改用collections.deque。

Operation

Average Case

Copy

O(n)

O(n)

Append[1]

O(1)

O(1)

Pop last

O(1)

O(1)

Pop intermediate[2]

O(n)

O(n)

Insert

O(n)

O(n)

Get Item

O(1)

O(1)

Set Item

O(1)

O(1)

Delete Item

O(n)

O(n)

Iteration

O(n)

O(n)

Get Slice

O(k)

O(k)

Del Slice

O(n)

O(n)

Set Slice

O(k+n)

O(k+n)

Extend[1]

O(k)

O(k)

O(n log n)

O(n log n)

Multiply

O(nk)

O(nk)

x in s

O(n)

min(s),max(s)

O(n)

Get Length

O(1)

O(1)

(2)双端队列：collections.deque

双端队列(双端队列)在内部表示为双链表。 (为得到更高的效率，是数组而不是对象的列表。)两端都是可访问的，但即使查找中间也很慢，而向中间添加或从中间删除仍然很慢。

Operation

Average Case

Amortized Worst Case

Copy

O(n)

O(n)

append

O(1)

O(1)

appendleft

O(1)

O(1)

pop

O(1)

O(1)

popleft

O(1)

O(1)

extend

O(k)

O(k)

extendleft

O(k)

O(k)

rotate

O(k)

O(k)

remove

O(n)

O(n)

(3)集合：set

参考dict，故意实现很相似。

Operation

Average case

Worst Case

notes

x in s

O(1)

O(n)

Intersection s&t

O(min(len(s),len(t))

O(len(s) * len(t))

replace "min" with "max" if t is not a set

Multiple intersection s1&s2&..&sn

(n-1)*O(l) where l is max(len(s1),..,len(sn))

Difference s-t

O(len(s))

s.difference_update(t)

O(len(t))

Symmetric Difference s^t

O(len(s))

O(len(s) * len(t))

s.symmetric_difference_update(t)

O(len(t))

O(len(t) * len(s))

As seen in the source code the complexities for set difference s-t or s.difference(t) (set_difference()) and in-place set difference s.difference_update(t) (set_difference_update_internal()) are different! The first one is O(len(s)) (for every element in s add it to the new set,if not in t). The second one is O(len(t)) (for every element in t remove it from s). So care must be taken as to which is preferred,depending on which one is the longest set and whether a new set is needed.

To perform set operations like s-t,both s and t need to be sets. However you can do the method equivalents even if t is any iterable,for example s.difference(l),where l is a list.

(4)子字典：dict

为dict对象列出的平均情况时间假设对象的哈希函数足够强大，以至于不常见冲突。 平均情况假设参数中使用的键是从所有键集中随机选择的。

请注意，有一种快速的命令可以(实际上)仅处理str键。 这不会影响算法的复杂性，但是会显着影响以下恒定因素：典型程序的完成速度。

Operation

Average Case

Amortized Worst Case

k in d

O(1)

O(n)

Copy[3]

O(n)

O(n)

Get Item

O(1)

O(n)

Set Item[1]

O(1)

O(n)

Delete Item

O(1)

O(n)

Iteration[3]

O(n)

O(n)

Notes

[1] = These operations rely on the "Amortized" part of "Amortized Worst Case". Individual actions may take surprisingly long,depending on the history of the container.

[2] = Popping the intermediate element at index k from a list of size n shifts all elements after k by one slot to the left using memmove. n - k elements have to be moved,so the operation is O(n - k). The best case is popping the second to last element,which necessitates one move,the worst case is popping the first element,which involves n - 1 moves. The average case for an average value of k is popping the element the middle of the list,which takes O(n/2) = O(n) operations.

[3] = For these operations,the worst case n is the maximum size the container ever achieved,rather than just the current size. For example,if N objects are added to a dictionary,then N-1 are deleted,the dictionary will still be sized for N objects (at least) until another insertion is made.

参考：https://wiki.python.org/moin/TimeComplexity

总结

如果觉得编程之家网站内容还不错，欢迎将编程之家网站推荐给程序员好友。

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。

如您喜欢交流学习经验，点击链接加入交流1群：1065694478(已满)交流2群：163560250