标准容器的复杂性保证是啥？

Posted 2023-02-15

【中文标题】标准容器的复杂性保证是啥？

【英文标题】：What are the complexity guarantees of the standard containers?标准容器的复杂性保证是什么？

【发布时间】：2010-09-15 22:50:42

【问题描述】：

显然 ;-) 标准容器提供了某种形式的保证。

什么类型的保证，不同类型的容器到底有什么区别？

从the SGI page 工作（关于STL）我想出了这个：

Container Types:
================
Container:
    Forward Container
        Reverse Container
            Random Access Container
    Sequence
        Front Insert Sequence
        Back  Insert Sequence
    Associative Container
        Simple   Associative Container
        Pair     Associative Container
        Sorted   Associative Container
        Multiple Associative Container

Container Types mapped to Standard Containers
=============================================

std::vector:    Sequence    Back        Sequence                    Forward/Reverse/Random Container
std::deque:     Sequence    Front/Back  Sequence                    Forward/Reverse/Random Container
std::list:      Sequence    Front/Back  Sequence                    Forward/Reverse Container
std::set:       Sorted/Simple/Unique    Associative Container       Forward Container
std::map:       Sorted/Pair/Unique      Associative Container       Forward Container
std::multiset:  Sorted/Simple/Multiple  Associative Container       Forward Container
std::multimap:  Sorted/Pair/Multiple    Associative Container       Forward Container


Container Guarantees:
=====================

                                                                                  Simp
                                                                                  or
                          For   Rev  Rand        Front  Back  Assoc        Sort   Mult
                    Cont: Cont: Cont Cont: Sequ: Sequ:  Sequ: Cont:        Cont:  Cont:
Copy    Const:      O(n)
Fill    Const:                             O(n)
begin()             O(1)
end()               O(1)
rbegin()                        O(1)
rend()                          O(1)
front()                                    O(1)
push_front()                                     O(1)
pop_front()                                      O(1)
push_back()                                             O(1)
pop_back()                                              O(1)
Insert()                                                                          O(ln(n))
Insert: fill                               O(n)
Insert: range                              O(n)                                   O(kln(n)+n)
size()              O(1)
swap()              O(1)
erase key                                                     O(ln(n))
erase element                                                 O(1)
erase range                                                   O(ln(n)+S)
count()                                                       O(log(n)+k)
find()                                                        O(ln(n))
equal range                                                   O(ln(n))
Lower Bound/Upper Bound                                                    O(ln(n))
Equality                  O(n)
InEquality                O(n)
Element Access                       O(1)

【问题讨论】：

从这里开始：STL Complexity Specifications。然后通读该站点上的所有容器类型，并查看所述的复杂性要求。希望这会有所帮助！

我可以有一份你的作品在我的课堂上学习吗？

@nXqd：见 www.sgi.com/tech/stl

@MartinYork 该链接现已失效。

john-ahlgren.blogspot.com/2013/10/… 看看这里 :)

【参考方案1】：

github page 上提供了另一个快速查找表

注意：这并没有考虑所有容器，例如 unordered_map 等，但仍然很好看。它只是this的更简洁版

【参考方案2】：

我找到了很好的资源Standard C++ Containers。可能这就是你们都在寻找的。​​p>

矢量

构造函数

vector<T> v;              Make an empty vector.                                     O(1)
vector<T> v(n);           Make a vector with N elements.                            O(n)
vector<T> v(n, value);    Make a vector with N elements, initialized to value.      O(n)
vector<T> v(begin, end);  Make a vector and copy the elements from begin to end.    O(n)

访问器

v[i]          Return (or set) the I'th element.                        O(1)
v.at(i)       Return (or set) the I'th element, with bounds checking.  O(1)
v.size()      Return current number of elements.                       O(1)
v.empty()     Return true if vector is empty.                          O(1)
v.begin()     Return random access iterator to start.                  O(1)
v.end()       Return random access iterator to end.                    O(1)
v.front()     Return the first element.                                O(1)
v.back()      Return the last element.                                 O(1)
v.capacity()  Return maximum number of elements.                       O(1)

修饰符

v.push_back(value)         Add value to end.                                                O(1) (amortized)
v.insert(iterator, value)  Insert value at the position indexed by iterator.                O(n)
v.pop_back()               Remove value from end.                                           O(1)
v.assign(begin, end)       Clear the container and copy in the elements from begin to end.  O(n)
v.erase(iterator)          Erase value indexed by iterator.                                 O(n)
v.erase(begin, end)        Erase the elements from begin to end.                            O(n)

其他容器请参考页面

【参考方案3】：

我不知道有什么可以让您一目了然地比较所有表格的单一表格（我不确定这样的表格是否可行）。

当然，ISO 标准文档详细列举了复杂性要求，有时在各种可读性很强的表格中，有时在每个特定方法的可读性较差的项目符号中。

http://www.cplusplus.com/reference/stl/ 上的 STL 库参考也提供了适当的复杂性要求。

【讨论】：

cplusplus.com 上的信息已过时（有时是错误的）。请改为将人们推荐给en.cppreference.com/w/cpp/container。每个容器的每种方法都列出了其规定的复杂性。