Quali sono le garanzie di complessità dei contenitori standard?


160

Apparentemente ;-) i contenitori standard offrono qualche forma di garanzie.

Che tipo di garanzie e quali sono esattamente le differenze tra i diversi tipi di container?

Lavorando dalla pagina SGI (su STL ) ho pensato a questo:

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)

Inizia qui: Specifiche di complessità STL . Quindi leggi tutti i tipi di container su quel sito e osserva i requisiti di complessità indicati. Spero che questo ti aiuti!
Chris Jester-Young,

1
Posso avere una copia del tuo lavoro per studiare nella mia classe?
Dzung Nguyen,

1
@nXqd: vedi www.sgi.com/tech/stl
Martin York

1
@MartinYork Quel link ora è morto.
Chani,

2
john-ahlgren.blogspot.com/2013/10/… Basta dare un'occhiata qui :)
Shalomi11

Risposte:


72

Ho trovato la bella risorsa Standard C ++ Containers . Probabilmente questo è quello che state cercando.

VETTORE

Costruttori

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)

di accesso

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)

modificatori

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)

Per altri contenitori, consultare la pagina.


6

Non sono a conoscenza di qualcosa come un singolo tavolo che ti consente di confrontarli tutti in una sola occhiata (non sono sicuro che un tale tavolo sarebbe nemmeno fattibile).

Naturalmente il documento standard ISO elenca i requisiti di complessità in dettaglio, a volte in varie tabelle piuttosto leggibili, altre volte in punti elenco meno leggibili per ciascun metodo specifico.

Anche il riferimento alla libreria STL su http://www.cplusplus.com/reference/stl/ fornisce i requisiti di complessità ove appropriato.


0

Un'altra tabella di ricerca rapida è disponibile in questa pagina github

Nota: questo non considera tutti i contenitori come, unordered_map ecc., Ma è comunque ottimo da guardare. È solo una versione più pulita di questo

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.