Quais são as garantias de complexidade dos contêineres padrão?

160

Aparentemente ;-) os contêineres padrão fornecem alguma forma de garantia.

Que tipo de garantias e quais são exatamente as diferenças entre os diferentes tipos de contêiner?

Trabalhando na página da SGI (sobre STL ), eu vim com isso:

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(n)
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)
Martin York
fonte
Comece aqui: Especificações da complexidade do STL . Em seguida, leia todos os tipos de contêineres nesse site e verifique os requisitos de complexidade estabelecidos. Espero que isto ajude!
9138 Chris Jester-Young #
1
Posso ter uma cópia do seu trabalho para estudar na minha classe?
Dzung Nguyen
1
@nXqd: consulte www.sgi.com/tech/stl
Martin York
1
@MartinYork Esse link está morto agora.
Chani
2
john-ahlgren.blogspot.com/2013/10/... Basta dar uma olhada aqui :)
Shalomi11

Respostas:

72

Encontrei o bom recurso Standard C ++ Containers . Provavelmente é isso que você está procurando.

VETOR

Construtores

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)

Accessors

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)

Modificadores

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)

Para outros recipientes, consulte a página.

Nayana Adassuriya
fonte
6

Não conheço nada parecido com uma única tabela que permita comparar todas elas de uma só vez (não tenho certeza se essa tabela seria viável).

Obviamente, o documento padrão da ISO enumera os requisitos de complexidade em detalhes, às vezes em várias tabelas bastante legíveis, outras em pontos de marcador menos legíveis para cada método específico.

Além disso, a referência da biblioteca STL em http://www.cplusplus.com/reference/stl/ fornece os requisitos de complexidade, quando apropriado.

Michael Burr
fonte
0

Outra tabela de pesquisa rápida está disponível nesta página do github

Nota: Isso não considera todos os contêineres, como unordered_map etc., mas ainda é ótimo de se olhar. É apenas uma versão mais limpa deste

iamakshatjain
fonte