Các đảm bảo phức tạp của các container tiêu chuẩn là gì?

Rõ ràng ;-) các container tiêu chuẩn cung cấp một số hình thức bảo đảm.

Loại bảo lãnh nào và chính xác sự khác biệt giữa các loại container khác nhau là gì?

Làm việc từ trang SGI (về STL ) Tôi đã nghĩ ra điều này:

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)

Tôi tìm thấy các tài nguyên tốt đẹp C ++ Container . Có lẽ đây là những gì tất cả các bạn đang tìm kiếm.

YAMOR

Người xây dựng

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)

Phụ kiệ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)

Công cụ sửa đổi

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)

Đối với các container khác, tham khảo trang.

Tôi không biết bất cứ điều gì như một bảng duy nhất cho phép bạn so sánh tất cả chúng trong nháy mắt (Tôi không chắc một bảng như vậy thậm chí có thể khả thi hay không).

Tất nhiên, tài liệu tiêu chuẩn ISO liệt kê các yêu cầu phức tạp một cách chi tiết, đôi khi trong các bảng khác nhau dễ đọc hơn, các lần khác trong các dấu đầu dòng ít đọc hơn cho mỗi phương pháp cụ thể.

Ngoài ra, tham chiếu thư viện STL tại http://www.cplusplus.com/reference/stl/ cung cấp các yêu cầu phức tạp khi thích hợp.

Một bảng tra cứu nhanh khác có sẵn tại trang github này

Lưu ý: Điều này không xem xét tất cả các vùng chứa, chẳng hạn như unordered_map, v.v. nhưng vẫn rất tuyệt để xem xét. Nó chỉ là một phiên bản sạch hơn của điều này