C++STL经常使用数据结构

参考连接： C++ STL-Multiset.emplace()函数

目录 

1、vector 

1.构造函数： 

2.插入函数： 

3.删除函数： 

4.查找函数 

5.大小函数 

6.其余函数 

2、stack 

3、array 

1.声明一个array 

2.迭代器函数 

3.数组大小函数 

4.元素访问函数 

5.其余函数 

4、list 

1.构造函数 

2.迭代器 

3.容量函数 

4.元素访问函数 

5.操做函数 

5、map 

1.构造函数 

2.迭代器 

3.容量函数 

4.元素访问函数 

5.插入函数 

6.删除函数 

7.操做函数 

6、queue 

1.构造函数 

2.其余函数 

7、priority_queue 

1.构造函数 

2.其余函数 

8、set 

1.构造函数 

2.迭代器 

3.容量函数 

4.插入函数 

5.删除函数 

6.其余函数 

9、multiset 

1、vector 

vector是一个能存听任意类型，包括自定义的对象的动态数组，定义一个vector不须要指定大小，它会根据里面的元素自动扩展大小。vector里面的元素线性排列，查找复杂度为O（1），可是在中间插入数据复杂度为O（n）。 

1.构造函数： 

vector<int> myVector;//建立一个空的vector，最经常使用的构造方法；

vector<int> myVector(n);//建立一个初始大小为n的vector，其中n能够是变量常量或者肯定的数字

vector<int> myVector(n,m);//建立一个初始大小为n的vector，而且全部值初始化为m，m和n能够是变量或者数字

vector<int> testVector(myVector);//建立一个vector而且将另外一个vector的值复制到这个新的vector里

vector<int> testVector(myVector.begin(), myVector.end());//传入两个vector的迭代器，而后将迭代器之间的值复制到新的vector里

 

2.插入函数： 

void push_back(int);//向vector的尾部插入一个元素

iterator insert(iterator it,const T& x);//向迭代器指向的位置以前插入一个元素x，返回x的位置

iterator insert(iterator it,int n,const T& x);//向迭代器指向的位置以前插入n个相同的元素x，返回插入的n个元素的第一个元素的位置

iterator insert(iterator it,const_iterator first,const_iterator last);//向迭代器指向的位置以前插入另外一个vector的迭代器区间的值，返回插入的全部元素的第一个元素的位置

 

3.删除函数： 

iterator erase(iterator it);//删除vector中迭代器指向的位置的元素，删除后此位置后面全部元素前移一位，返回位置为删除的元素的位置

iterator erase(iterator first,iterator last);//删除两个迭代器之间的元素（不包括last位置的元素），返回first位置迭代器

void pop_back();//删除最后一个元素

void clear();//清空vector全部元素 

4.查找函数 

reference at(int pos);//返回pos位置元素的引用

reference front();//返回首元素的引用

reference back();//返回尾元素的引用

iterator begin();//返回向量头指针，指向第一个元素

iterator end();//返回向量尾指针，指向向量最后一个元素的下一个位置

reverse_iterator rbegin();//反向迭代器，指向最后一个元素

reverse_iterator rend();//反向迭代器，指向第一个元素以前的位置 

5.大小函数 

int size() const;//返回vector里元素的个数

int capacity() const;//返回当前vector的容量，实测size为1是容量为1，size为2时容量为2，size为3，4是容量为4，size为5~8时容量为8……因此capacity函数为vector能容下全部元素的最小的2的指数容量。

int max_size() const;//返回vector容许的最大元素个数，即size的最大值，若是插入的元素个数超过这个值应该会报错，本想实测一下可是内存不够

 

6.其余函数 

bool empty() const;//判断vector里面是否有元素，有则返回false，没有则返回true

void swap(vector&, vector&);//交换两个值

void assign(int n,const T& x);//清空vector而且设置n个元素，值为x

void assign(const_iterator first,const_iterator last);//清空vector而且吧迭代器区间里的元素复制到vector里 

2、stack 

bool empty() const;//若是栈空返回true，不然返回false

size_type size() const;//返回栈的元素个数

value_type& top();//返回栈顶元素

void push (const value_type& val);//将一个值val压栈

template <class... Args> void emplace (Args&&... args);//调用stack元素的类型的构造函数用参数构造出一个元素，而后压栈，与push不一样的是它避免了对象的拷贝，效率更高

void pop();//将栈顶元素出栈

 

  

3、array 

1.声明一个array 

array<int,5> arr;//声明一个大小为5的数组，若是是局部变量则不会初始化，值是随机的，若是是全局变量会初始化为0

array<int,4> arr = {1,2,3,4};//声明一个大小为4并初始化的数组，若是初始值数量小于数组大小，则后面的数组值初始化为0

 

2.迭代器函数 

iterator begin();//返回数组首元素的迭代器

iterator end();//返回数组最后一个元素的下一个位置的迭代器

 

3.数组大小函数 

size_type size();//返回数组大小

size_type max_size();//返回array能支持的最大容量，可是实际max_size的值和size同样

bool empty();//只有当数组size为0是返回true，感受没什么意义 

4.元素访问函数 

reference at ( size_type n );//返回数组下标为n的元素的引用

reference front();//返回数组第一个元素的引用

reference back();//返回最后一个元素的引用

value_type* data();//返回一个指向数组首元素的指针 

5.其余函数 

void fill (const value_type& val);//将数组里的元素所有填充为val

void swap(&array arr);//例如arr1.swap(arr2)，则将arr1和arr2两个数组里的全部元素交换，两个array元素数量必须同样，不然会编译出错 

4、list 

1.构造函数 

list<int> first;//建立一个空的list

list<int> first = {1,2,3,4};//能够这样初始化

list<int> second (4,100);//建立一个有四个节点的list，初始化为100

list<int> third (second.begin(),second.end());//使用迭代器初始化list

list<int> fourth (third);//拷贝一个list

 

2.迭代器 

iterator begin();//返回第一个元素的迭代器

iterator end();//返回最后一个元素的下一个位置的迭代器

 

3.容量函数 

bool empty() const;//若是list为空返回true，不然返回false

size_type size() const;//返回list当前的元素个数

size_type max_size() const;//返回list能支持的最大容量 

4.元素访问函数 

reference front();//返回list第一个元素的引用

reference back();//返回list最后一个元素的引用 

5.操做函数 

void assign (size_type n, const value_type& val);//清空list并设置n个值为val的元素

void assign (InputIterator first, InputIterator last);//清空list并将迭代器区间的值拷贝到list里

/********************list的插入函数*********************************************/

void emplace_front (Args&&... args);//调用list类型的构造函数使用参数列表构造一个list类型对象并插入到list的头部

void emplace_back (Args&&... args);//与上一个相似，区别在于插入到list的尾部

iterator emplace (const_iterator position, Args&&... args);//和上面两个相似，区别在于插入到迭代器position位置的前面，并返回插入元素的迭代器

void push_front (const value_type& val);//将val插入到list的头部

void push_back (const value_type& val);//将val插入到list的尾部

iterator insert (iterator position, const value_type& val);//插入元素到position位置以前并返回插入元素的位置的迭代器

/*****************************************************************************/

/**********************list的删除函数*******************************************/

void pop_front();//删除头部元素

void pop_back();//删除尾部元素

iterator erase (iterator position);//删除position位置的元素并返回删除元素的下一个元素的迭代器

iterator erase (iterator first, iterator last);//删除迭代器区间的元素并返回迭代器区间的下一个位置

void remove (const value_type& val);//删除list里面值为val的节点

void remove_if (Predicate pred);//条件式删除，将list里全部元素依次传入函数pred里，若是返回true，则删除这个节点

void unique();//删除list里相邻节点重复的元素，即若是两个节点相邻且值相等则会删除其中一个

void unique (BinaryPredicate binary_pred);//带参数的unique，即只要两个相邻节点传入binary_pred后返回true则会删除其中一个

void clear();//清空list

/**************************************************************************/

void swap (list& x);//list的元素交换函数

void resize (size_type n);//若是list大小大于n，则截断list只保留前n个元素，若是大小小于n，则将list尾部连续插入0知道size等于n

void resize (size_type n, const value_type& val);//与上一个相似，区别在于若是list的size小于n，则填充val而不是0

/****************************list剪切*************************************/

void splice (iterator position, list& x);//将list x的全部元素剪切并插入到调用函数的list的position位置以前

void splice (iterator position, list& x, iterator i);//将list x的迭代器i指向的元素剪切并插入到调用函数的list的position位置以前

void splice (iterator position, list& x, iterator first, iterator last);//将list x的迭代器first和last之间的元素剪切并插入到调用函数的list的position位置以前

/***************************************************************************/

/***********************************list排序函数***************************/

void merge (list& x);//将两个list进行归并排序，结果保存在调用函数的list中，而且结束以后list x会为空

void merge (list& x, Compare comp);//按条件comp进行归并排序，与上一个相似

void sort();//list的排序

void sort (Compare comp);//按条件排序

void reverse();//将list全部元素顺序颠倒 

5、map 

1.构造函数 

std::map<char,int> first;//构造一个空的map

std::map<char,int> second (first.begin(),first.end());//构造一个map并初始化为另外一个map的一个区间的元素

std::map<char,int> third (second);//构造一个map并初始化为另外一个map的全部元素

std::map<char,int,classcomp> fourth; //构造一个map并根据classcomp函数进行排序（并非很清楚，这是个人猜测）

 

2.迭代器 

iterator begin();//返回第一个元素的迭代器

iterator end();//返回最后一个元素的下一个位置的迭代器 

3.容量函数 

bool empty() const;//若是map为空返回true，不然返回false

size_type size() const;//返回map当前的元素个数

size_type max_size() const;//返回map能支持的最大容量 

4.元素访问函数 

mapped_type& at (const key_type& k);//返回键为k的值 

5.插入函数 

pair<iterator,bool> insert (const value_type& val);//插入一对键值对，返回一个pair对象，一般val值为构造的一个pair对象。若是插入成功，则返回值pair.second为true且pair.first指向插入元素的迭代器。若是元素已存在会插入失败，pair.first指向已存在元素的迭代器

iterator insert (iterator position, const value_type& val);//在指定位置插入元素

void insert (InputIterator first, InputIterator last);//依次插入迭代器区间的值，不包括last指向的值

pair<iterator,bool> emplace (Args&&... args);//返回值与insert相同，插入效率比insert高，代码也更简单

iterator emplace_hint (const_iterator position, Args&&... args);//在指定位置插入元素，若是元素已经存在则返回元素的迭代器，不然返回插入以后元素的迭代器

map[key] = value;//map支持数组下标式赋值和插入 

6.删除函数 

void erase (iterator position);//删除迭代器指向的元素

size_type erase (const key_type& k);//删除键为k的元素，若是存在键为k的元素，则返回1，若是不存在则返回0

void erase (iterator first, iterator last);//删除迭代器区间的元素

void clear();//清空map 

7.操做函数 

void swap (map& x);//交换两个map的元素

iterator find (const key_type& k);//查找键为k的元素，返回元素的迭代器

size_type count (const key_type& k) const;//在map中查找键为k的元素，返回找到的元素的个数，由于map不能有两个元素键相同，因此只能返回0或1

iterator lower_bound (const key_type& k);//返回map里第一个键大于或等于k的元素迭代器

iterator upper_bound (const key_type& k);//返回map里第一个大于k的元素迭代器

equal_range (const key_type& k)；//返回lower_bound (const key_type& k)和upper_bound (const key_type& k)组成的一个pair对象 

6、queue 

1.构造函数 

queue (const container_type& ctnr = container_type());//构造一个queue须要两个参数，第一个是元素类型，第二个是queue的容器类型，其中第二个参数能够省略，则默认容器类型为dqueue

queue<int> first;//最经常使用的构造方式

queue<int> second (container);//能够用另外一个容器来初始化queue，若是queue没有指定容器类型

那么这里的container必须是一个dequeue类型的容器

queue<int,std::list<int> > third; //指定queue容器类型

queue<int,std::list<int> > fourth (mylist);//指定类型并初始化，在指定queue的容器类型后，若是要用另外一个容器来初始化queue，那么必须是queue的容器类型的容器 

2.其余函数 

bool empty() const;//若是队列为空返回true，不然返回false

size_type size() const;//返回队列的元素个数

value_type& front();//返回队首元素

value_type& back();//返回队尾元素

void push (const value_type& val);//向队列插入一个元素，插入在队尾

void emplace (Args&&... args);//构造并向队列插入一个元素，插入在队尾

void pop();//将队列头部一个元素出队

 

7、priority_queue 

1.构造函数 

priority_queue<int> first;//构造一个普通的优先队列，默认队列首部值最大

priority_queue<int> second (myints,myints+4);//使用一个数组初始化优先队列

priority_queue<int, std::vector<int>, std::greater<int> > third (myints,myints+4);

//这里指定优先级方式为greater，则最小的元素会在队首

priority_queue<int, std::vector<int>, mycomparison> //自定义优先级函数mycomparison 

2.其余函数 

优先队列没有取队尾元素的函数，取队首元素的函数为 

value_type& top() const; 

其余函数与queue同样 

  

8、set 

1.构造函数 

set<int> first;//构造一个空的集合

set<int> second (myints,myints+5);//定义一个集合并使用数组初始化

set<int> third (second);//构造一个集合并把另外一个集合的元素复制过来

set<int> fourth (second.begin(), second.end());//定义一个集合并使用迭代器区间初始化

set<int,classcomp> fifth;//定义一个集合并自定义集合里元素的排序方式 

2.迭代器 

iterator begin();//返回集合首元素的迭代器

iterator end();//返回集合最后一个元素的下一个位置的迭代器

 

3.容量函数 

bool empty() const;//若是集合为空返回true，不然返回false

size_type size() const;//返回集合元素的个数

size_type max_size() const;//返回集合能支持的最大容量 

4.插入函数 

pair<iterator,bool> insert (const value_type& val);//插入一个元素，若是元素已经存在，那么返回这个元素的迭代器，不然返回插入成功后这个元素的迭代器

iterator insert (iterator position, const value_type& val);//在指定位置插入元素，这个函数的意义在于，若是在指定位置插入元素以后集合已经有序了，那么就不用再排序，因此有时候会比上一个效率更高

void insert (InputIterator first, InputIterator last);//插入两个迭代器之间的一组数据

pair<iterator,bool> emplace (Args&&... args);//比insert更高效的插入方法

iterator emplace_hint (const_iterator position, Args&&... args);//在指定位置插入元素 

5.删除函数 

void erase (iterator position);//删除迭代器指向的位置的元素

size_type erase (const value_type& val);//删除值为val的元素，返回删除的数目，因为set元素不容许重复，因此若是删除成功返回1，删除失败返回0

void erase (iterator first, iterator last);//删除迭代器区间的元素

void clear();//清空集合 

6.其余函数 

iterator find (const value_type& val) const;//查找值为val的元素，返回迭代器，若是查找失败返回set.end()迭代器

size_type count (const value_type& val) const;//查找值为val的元素的个数，由于set不容许元素重复，因此只能返回0或1

iterator lower_bound (const value_type& val) const;//返回元素值大于等于val的第一个元素的位置

iterator upper_bound (const value_type& val) const;//返回元素值大于val的第一个元素的位置

pair<iterator,iterator> equal_range (const value_type& val) const;//返回以val为参数的lower_bound和upper_bound组成的pair 

9、multiset 

multset和set的区别是它容许元素的值相同，这个区别致使如下函数的不一样： 

count函数能返回大于1的值 

insert函数插入已经存在的元素能成功 

按值删除一个元素会把值相同的全部元素删除 

查找一个值会返回找到的第一个元素的位置 

其余函数应该都相同