算法

数据结构（C++）

顺序容器

• 静态的连续数组 array
• 动态的连续数组 vector
• 双端队列 deque
• 单链表 forward_list
• 双链表 list

关联容器

• 唯一键的集合，按照键排序 set
• 键值对的集合，按照键排序，键是唯一的 map
• 键的集合，按照键排序 multiset
• 键值对的集合，按照键排序 multimap

无序关联容器

• 唯一键的集合，按照键生成散列 unordered_set
• 键值对的集合，按照键生成散列，键是唯一的 unordered_map
• 键的集合，按照键生成散列 unordered_multiset
• 键值对的集合，按照键生成散列 unordered_multimap

容器适配器

• 适配一个容器以提供栈（LIFO数据结构） stack
• 适配一个容器以提供队列（FIFO数据结构） queue
• 适配一个容器以提供优先级队列 priority_queue

详细内容

1. 顺序容器
   array(C++11开始)

template <class T, std::size_t N> struct array;

vector\deque\forward_list\list

template <class T, class Allocator = std::allocator<T> > class vector;
template <class T, class Allocator = std::allocator<T> > class deque;
template <class T, class Allocator = std::allocator<T> > class forward_list;
template <class T, class Allocator = std::allocator<T> > class list;

2. 关联容器
   set\map\multiset\multimap

template<
    class Key,
    class Compare = std::less<Key>,
    class Allocator = std::allocator<Key>
> class set;
template<
    class Key,
    class T,
    class Compare = std::less<Key>,
    class Allocator = std::allocator<std::pair<const Key, T> >
> class map;
template<
    class Key,
    class Compare = std::less<Key>,
    class Allocator = std::allocator<Key>
> class multiset;
template<
    class Key,
    class T,
    class Compare = std::less<Key>,
    class Allocator = std::allocator<std::pair<const Key, T> >
> class multimap;

3. 无序关联容器
   unordered_set\unordered_map\unordered_multiset\unordered_multimap

template<
    class Key,
    class Hash = std::hash<Key>,
    class KeyEqual = std::equal_to<Key>,
    class Allocator = std::allocator<Key>
> class unordered_set;
template<
    class Key,
    class T,
    class Hash = std::hash<Key>,
    class KeyEqual = std::equal_to<Key>,
    class Allocator = std::allocator< std::pair<const Key, T> >
> class unordered_map;
template<
    class Key,
    class Hash = std::hash<Key>,
    class KeyEqual = std::equal_to<Key>,
    class Allocator = std::allocator<Key>
> class unordered_multiset;
template<
    class Key,
    class T,
    class Hash = std::hash<Key>,
    class KeyEqual = std::equal_to<Key>,
    class Allocator = std::allocator< std::pair<const Key, T> >
> class unordered_multimap;

4. 容器适配器
   stack\queue\priority_queue

template<
    class T,
    class Container = std::deque<T>
> class stack;
template<
    class T,
    class Container = std::deque<T>
> class queue;
template<
    class T,
    class Container = std::vector<T>,
    class Compare = std::less<typename Container::value_type>
> class priority_queue;

算法-基础知识汇总

原文：https://www.cnblogs.com/liutianchen/p/14290879.html