C++ STL

Standard Template Library (STL) is a library that consist of different data structures and algorithms to effectively store and manipulate data.

Containers

Containers are data structures that provides a way to store data, like vector, lists, etc.

Sequence Containers
- These containers stores elements in a linear sequence and provide sequential access to elements
- Main Types:
  - vector : Dynamically contiguous array with efficient and operations
  - list : Doubly-linked list with efficient insertions/deletions
  - deque : Double-ended queue allowing operations at both ends
  - array : Fixed-size contiguous array
  - forward_list : Singly-linked list
Associative Containers
- These containers implement sorted data structures that maintain elements in a specific order.
- Characteristics:
  - Elements are automatically sorted
  - Fast searching with O(log n) complexity
  - Implemented using balanced binary search trees(Red-Black Tree)
  - Main types include:
    - set : Collection of unique keys
    - map : Collection of key-value pairs
    - multiset : Allows duplicate keys
    - multimap : Allows duplicate key-value pairs
Unordered Associative Containers
- These containers use hash tables for elements storage.
- Key Features:
  - Elements are not sorted
  - Average O(1) access time
  - Uses hashing for element storage
  - Main types include:
    - unordered_set : Hash table with unique keys
    - unordered_map : Hash table with unique key-value pairs
    - unordered_multiset : Hash table allowing duplicate keys
    - unordered_multimap : Hash table allowing duplicate key-value pairs

Iterators

Iterators are objects used to access elements of a data structure.

Algorithms

Algorithms include functions, like sort() and find(), that perform operations on data structures through iterators.

Data Structure	Description
vector	Stores elements like an array but can dynamically change in size. Adding and removing of elements are usually done at the end. Elements can be accessed by index.
list	Stores elements sequentially, where each element is connected to the next. Adding and removing of elements can be done at both ends. Not accessible by index.
stack	Stores elements in a specific order, called LIFO (Last In, First Out), where elements are added at the end and removed from the top. Not accessible by index.
queue	Stores elements in a specific order, called FIFO (First In, First Out), where elements are added at the end and removed from the front. Not accessible by index.
deque	Stores elements in a double-ended queue, where elements can be added and removed from both ends. Elements can be accessed by index.
set	Stores unique elements. Not accessible by index.
map	Stores elements in “key/value” pairs. Accessible by keys (not by index).

#include <vector>
#include <list>
#include <set>
#include <map>
#include <stack>
#include <queue>