what complexity guarantees customary containers?

apparently ;-) customary containers yield form guarantees.

what form guarantees accurately differences between opposite forms container?

working (about ) i have adult this:

container types:
================
container:
    disrespectful container
        shelter container
            futile opening container
    sequence
        front insert sequence
        behind  insert sequence
    associative container
        rudimentary   associative container
        camber     associative container
        sorted   associative container
        churned associative container

container forms mapped customary containers
=============================================

std::vector:    method    behind        method                    forward/reverse/random container
std::deque:     method    front/back  method                    forward/reverse/random container
std::list:      method    front/back  method                    forward/reverse container
std::set:       sorted/simple/unique    associative enclosing       disrespectful container
std::map:       sorted/pair/unique      associative enclosing       disrespectful container
std::multiset:  sorted/simple/multiple  associative enclosing       disrespectful container
std::multimap:  sorted/pair/multiple    associative enclosing       disrespectful container


container guarantees:
=====================

                                                                                  simp
                                                                                  or
                            rev  rand        front  behind  assoc        arrange   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: operation                              o(n)                                   o(kln(n)+n)
size()              o(n)
swap()              o(1)
erase pivotal                                                     o(ln(n))
erase component                                                 o(1)
erase operation                                                   o(ln(n)+s)
count()                                                       o(log(n)+k)
find()                                                        o(ln(n))
equal operation                                                   o(ln(n))
lower bound/upper organization                                                    o(ln(n))
equality                  o(n)
inequality                o(n)
element opening                       o(1)