Quelles sont les garanties de complexité des conteneurs standards?


160

Apparemment ;-) les conteneurs standards offrent une certaine forme de garantie.

Quels types de garanties et quelles sont exactement les différences entre les différents types de conteneurs?

En travaillant à partir de la page SGI (à propos de STL ), j'ai trouvé ceci:

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)

Commencez ici: Spécifications de complexité STL . Ensuite, parcourez tous les types de conteneurs sur ce site et examinez les exigences de complexité énoncées. J'espère que cela t'aides!
Chris Jester-Young

1
Puis-je avoir une copie de votre travail pour étudier dans ma classe?
Dzung Nguyen

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

1
@MartinYork Ce lien est maintenant mort.
Chani

Réponses:


72

J'ai trouvé la belle ressource Conteneurs C ++ standard . C'est probablement ce que vous recherchez tous.

VECTEUR

Constructeurs

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)

Accesseurs

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)

Modificateurs

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)

Pour les autres conteneurs, reportez-vous à la page.


6

Je ne connais rien de tel qu'un seul tableau qui vous permette de tous les comparer en un seul coup d'œil (je ne suis pas sûr qu'un tel tableau serait même réalisable).

Bien sûr, le document standard ISO énumère les exigences de complexité en détail, parfois dans divers tableaux assez lisibles, d'autres fois dans des puces moins lisibles pour chaque méthode spécifique.

La référence de la bibliothèque STL à l' adresse http://www.cplusplus.com/reference/stl/ fournit les exigences de complexité, le cas échéant.


0

Une autre table de recherche rapide est disponible sur cette page github

Remarque: Cela ne prend pas en compte tous les conteneurs tels que, unordered_map, etc., mais reste agréable à regarder. C'est juste une version plus propre de ceci

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.