Container
=========

Name           vector                     list                       array               deque               set                                  map                                 unordered_set / (unordered_map)
               (string)

Typ            Sequentieller Container    Doppelt verkettete Liste   Seq. Container      double ended que    "TreeSet"                             "TreeMap"                           "HashSet"
               Feld                       Sequentieller Container    Feld fester Größe   Seq. Container      Baum                                  Baum bzgl. Key                      Hash-Container
               Dynamisches Feld           Dynamisch                  Statisch            Dynamisch           Rot-Schwarz                           Rot-Schwarz
                                                                                                             Binäre                                Binär
                                                                                                             ausbalancierter                       ausbalancierter
                                                                                                             Mathematische Menge                   M Menge bgl. Key                    Mathematische Menge
                                                                                                             sortiert                              sortiert bzgl. Key                  "zufällige" Reihenfolge
                                                                                                             Container verändert die Reihenfolge   C v R                               Container verändert die Reihenfolge         
                                                                                                                                                   Key -> Value Abb.
                                                                                                                                                   Assoziativer Container

R/A            ++                         /                          +++                  +                  /                                     /                                   /

Einfügen                                                             /                                       o (sehr gutes o)                      o (sehr gutes o)                    + (--)
- Hinten       ++ (--)                     +                                              ++ (+)
- Mitte         -                          + (--) 1                                       --
- Vorne        --                          +                                              ++ (+)

Löschen                                                              /                                       o (sehr gutes o)                      o (sehr gutes o)                   +
- Hinten       ++                          +                                              ++ (+)             
- Mitte         -                          + (--) 1                                       --
- Vorne        --                          +                                              ++ (+)

Suchen 3       --                         --                         --                   --                 ++                                    ++                                 +++  

Cache-Fr.      ++                         --                         +++                  +                  --                                    --                                 o

Speicher-Nutz. 82%                        4-99,9%                    100%                 99% 2              4-99%                                 8-99,9%                            10%-90%



---

R/A - Random Access - Wahlfreier Zugriff

Cache-Fr. - Cache Freundlichkeit

Sequentieller Container 
- Elemente liegen logisch hintereinadner
- => Erstes Element, letztes Element
- Wir als Entwickler bestimmen die Reihenfolge

Feld - elemente liegen bündig im Speicher hintereinander

Lineare Suchen: durchlaufen durch den Container


---

1. - unter der Bedingung, dass wir die Position haben, ansonsten --
2. - wenn nicht nur sehr wenige Elemente
3. - beim Suchen ist schon O(ln2(n)) ++
         
---

Hashing

2^64 = 16 Trillionen
256^16 Trillionen => Anzahl an möglichen Texten
=> Beim Hashen muss es Kollisionen gibt (gleicher Hash-Wert)

=> Hash-Wert % Größe-des-internen-Arrays => noch mehr Kollisionen

---

unordered_map 
- eine "normale" Map, daher assoziativer Container (Schlüssel => Wert Abbildung)
- Aber mit Hashing über den Schlüssel

---

Stack
- Stapelspeicher
- Last-in - First-Out (LiFo-Prinzip)
- First-In - Last-Out 
- Container-Adapter
  - basiert intern in C++ auf der deque

---

Zeitkomplexität
O(1)        - konstant, konstante Zeit => +/++
O(log2(n))  - 2 er logarithmus Zeit    => ++/+/o      Kontext-abhängig
O(n)        - linear                   => -/--

---


  Anzahl Elemente im:         Seq. Container              Set                 HashSet
         
           10                             5                 4                     2
           20                            10                 5                     2
           50                            25                 6                     2
          100                            50                 7                     2
        1.000                           500                10                     2
    1.000.000                       500.000                20                     2
1.000.000.000                   500.000.000                30                     2
