C++学习笔记（6）——标准模板库STL之vector和list

本篇文章整理了常用的成员函数。

一、动态数组vector

1.初始化

初始化为空：vector v;

用另一个vector来初始化，即构造一个副本：vector v(v1);

大小为n，并全部初始化为元素i ：vector v(n, i);

构造大小为n的容器，没有初始化里面的元素：vector (n);

构造大小为4，并初始化里面的各个元素：vector {1,2,3,4};

数组a[0]到a[5]的内容放进v：vector v(a, a+5);

2.元素个数

v.size(); //返回容器中元素的个数，返回类型是int

v.capacity(); //返回容器中的容量，容器的预留空间也会计算在内

3.添加/插入元素

v.push_back(n); //将n加到容器末尾

v.insert(i, n); //将n插入到迭代器i指向的位置，并返回i

v.insert(i, i_first, i_end); //将其他容器上的区间[i_first,i_end)中的元素插入到迭代器i指向的位置，并返回i

4.删除元素

v.pop_back(); //删除容器末尾的元素

v.clear(); //删除所有元素

v.erase(i); //删除迭代器i指向的位置

v.erase(i_first, i_end); //删除容器上的区间[i_first, i_end)的元素

5.其他

v.empty(); //判断容器是否为空，空返回1，非空返回0

v.swap(_v); //容器v和_v交换

v.reverse(); //将容器v倒置

注意：没有find函数！！！

6.实例

#include
#include
using namespace std;

void Print(const vector<int> &v)
{
	vector<int>::const_iterator i;
	for(i=v.begin(); i!=v.end(); ++i) cout<<*i<<" ";
	cout<<endl;
}

int main()
{
	int a[5] = {1, 2, 3, 4, 5};
	vector<int> v1(a, a+5);
	vector<int> v2(5, 0);
	vector<int>::iterator i;
	
	cout<<v1.empty()<<endl; //0
	cout<<v1.capacity()<<endl;
	
	v1.push_back(6);
	cout<<v1.end()-v1.begin()<<endl; //6
	Print(v1); //1 2 3 4 5 6 
	v1.pop_back();
	
	v1.insert(v1.begin()+2, 10);
	Print(v1); //1 2 10 3 4 5
	
	v1.erase(v1.begin()+2);
	Print(v1); //1 2 3 4 5
	
	v1.insert(v1.begin()+1, v2.begin()+2, v2.end());
	Print(v1); //1 0 0 0 2 3 4 5
	
	v1.erase(v1.begin()+1, v1.begin()+4);
	Print(v1); //1 2 3 4 5
	
	v1.clear();
	cout<<v1.empty()<<endl; //1
	
	return 0;
}

二、双向链表list

注意：形如lst.begin()+2的语句会报错，因为list不支持根据下标随机存储元素。

1.初始化

初始化为空：list lst;

用另一个list来初始化，即构造一个副本：list lst(v1);

大小为n，并全部初始化为元素i ：list lst(n, i);

构造大小为n的容器，没有初始化里面的元素：list (n);

构造大小为4，并初始化里面的各个元素：list {1,2,3,4};

数组a[0]到a[5]的内容放进lst：list v(a, a+5);

2.元素个数

lst.size(); //返回容器中元素的个数，返回类型是int

3.添加/插入元素

lst.push_front(n); //将n加到容器最前面

lst.push_back(n); //将n加到容器末尾

lst.insert(i, n); //将n插入到迭代器i指向的位置，并返回i

lst.insert(i, i_first, i_end); //将其他容器上的区间[i_first,i_end)中的元素插入到迭代器i指向的位置，并返回i

lst.splice(i, _lst); //在位置i前面插入链表_lst，并将链表_lst清空，注意，_lst和lst不能是同一个链表

lst.splice(i, _lst, _i); //在位置i前面添加链表_lst位置_i上的元素，并将链表_lst位置_i的元素删除，注意，_lst和lst可以是同一个链表

lst.splice(i, _lst, i_first, i_end); //在位置i前面插入链表_lst中的区间[i_first, i_end)，并在链表_lst中删除该区间，注意，_lst和lst可以是同一个链表

lst.merge(_lst); //将链表_lst与lst合并，并清空_lst，注意，lst和_lst必须是有序的

4.删除元素

lst.pop_front(n); //删除最前面的元素

lst.pop_back(); //删除容器末尾的元素

lst.clear(); //删除所有元素

lst.erase(i); //删除迭代器i指向的位置

lst.erase(i_first, i_end); //删除容器上的区间[i_first, i_end)的元素

lst.unique(); //删除所有和前一个元素相等的元素，建议与sort()搭配使用

lst.remove(n); //删除所有和n相等的元素

5.其他

lst.sort(); //对链表从小到大排序

lst.empty(); //判断容器是否为空，空返回1，非空返回0

lst.swap(_lst); //容器lst和_lst交换

lst.reverse(); //将容器lst倒置

注意：没有find函数！！！

6.实例

#include
#include
#include
using namespace std;

void Print(const list<int> &lst)
{
	list<int>::const_iterator i;
	for(i = lst.begin(); i != lst.end(); ++i) cout<< *i << " ";
	cout<<endl;
}

int main()
{
	int a[5] = {3, 1, 2, 5, 4};
	int b[6] = {8, 7, 9, 10, 6, 6};
	list<int> lst1(a, a+5);
	list<int> lst2(b, b+6);
	cout<<lst1.size()<<endl; //5
	
	lst1.sort();
	Print(lst1); //1 2 3 4 5
	
	lst2.sort();
	lst2.unique();
	Print(lst2); //6 7 8 9 10
	
	lst1.merge(lst2);
	Print(lst1); //1 2 3 4 5 6 7 8 9 10
	cout<<lst2.empty()<<endl; //1
	
	list<int>::iterator p;
	p = find(lst1.begin(), lst1.end(), 6); //不属于list成员函数，需要包含algorithm头文件 
	lst2.splice(lst2.begin(), lst1, p, lst1.end());
	Print(lst1); //1 2 3 4 5
	Print(lst2); //6 7 8 9 10
	
	return 0;	
}

三、双向队列deque

deque也是可变长数组，相比于vector，deque的最大优点是在头部添加或删除元素都比vector快，因此它有以下vector没有的成员函数：

d.push_front(n); //将n加到容器最前面

d.pop_front(n); //删除最前面的元素

暂时写这么多，以后可能会有补充。