Jakie są gwarancje złożoności standardowych pojemników?

160

Najwyraźniej ;-) standardowe kontenery dają jakąś formę gwarancji.

Jakie rodzaje gwarancji i jakie dokładnie są różnice między różnymi typami kontenerów?

Pracując ze strony SGI (o STL ) wymyśliłem to:

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
źródło
Zacznij tutaj: Specyfikacje złożoności STL . Następnie przeczytaj wszystkie typy kontenerów w tej witrynie i spójrz na podane wymagania dotyczące złożoności. Mam nadzieję że to pomoże!
Chris Jester-Young
1
Czy mogę dostać kopię twojej pracy do nauki w mojej klasie?
Dzung Nguyen
1
@nXqd: patrz www.sgi.com/tech/stl
Martin York
1
@MartinYork Ten link jest teraz martwy.
Chani
2
john-ahlgren.blogspot.com/2013/10/ ... Wystarczy spojrzeć tutaj :)
Shalomi11

Odpowiedzi:

72

Znalazłem fajny zasób Standardowe kontenery C ++ . Prawdopodobnie tego właśnie szukacie.

WEKTOR

Konstruktorzy

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)

Akcesoria

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)

Modyfikatory

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)

Informacje na temat innych kontenerów można znaleźć na stronie.

Nayana Adassuriya
źródło
6

Nie znam czegoś takiego, jak pojedynczy stół, który pozwala porównać je wszystkie na pierwszy rzut oka (nie jestem pewien, czy taki stół byłby w ogóle możliwy).

Oczywiście dokument normy ISO szczegółowo wylicza wymagania dotyczące złożoności, czasami w różnych, raczej czytelnych tabelach, innym razem w mniej czytelnych punktach dla każdej konkretnej metody.

Również odniesienie do biblioteki STL pod adresem http://www.cplusplus.com/reference/stl/ zawiera wymagania dotyczące złożoności, jeśli to konieczne.

Michael Burr
źródło
0

Inna tabela szybkiego wyszukiwania jest dostępna na tej stronie github

Uwaga: nie uwzględnia wszystkich kontenerów, takich jak unordered_map itp., Ale nadal świetnie się na nie patrzy. To jest po prostu czystsza wersja tego

iamakshatjain
źródło