표준 컨테이너의 복잡성 보장은 무엇입니까?

분명히 ;-) 표준 컨테이너는 어떤 형태의 보증을 제공합니다.

어떤 유형의 보증과 다른 유형의 컨테이너 사이의 차이점은 정확히 무엇입니까?

SGI 페이지 ( STL 정보 ) 에서 작업 하면 다음과 같은 결과를 얻었습니다.

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)

좋은 리소스 Standard C ++ Containers를 찾았습니다. . 아마 이것은 당신이 찾고있는 것입니다.

벡터

생성자

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)

접근 자

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)

수정 자

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)

다른 용기에 대해서는 페이지를 참조하십시오.

나는 당신이 한 눈에 모든 것을 비교할 수있는 단일 테이블과 같은 것을 알지 못합니다 (그런 테이블이 가능할지는 확실하지 않습니다).

물론 ISO 표준 문서에는 복잡성 요구 사항이 상세하게, 때로는 읽기 어려운 다양한 표에서, 때로는 특정 방법마다 읽기 어려운 글 머리 기호로 자세히 설명되어 있습니다.

또한 http://www.cplusplus.com/reference/stl/ 의 STL 라이브러리 참조는 필요한 경우 복잡성 요구 사항을 제공합니다.

이 github 페이지 에서 다른 빠른 검색 테이블을 사용할 수 있습니다

참고 : 이것은 unorder_map 등과 같은 모든 컨테이너를 고려하지는 않지만 여전히보기에 좋습니다. 그것은 단지 클리너 버전 이