STL之list容器（超详细）

功能：将数据进行链式存储，链式存储就要提到C语言里的链表概念。

链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的

链表的组成：链表由一系列结点组成

结点的组成：一个是存储数据元素的数据域（储存的数据），另一个是存储下一个结点地址的指针域（存储下一个元素和前一个元素的地址）

STL中的链表是一个双向循环链表

 由于链表的存储方式并不是连续的内存空间，因此链表中的迭代器只支持前移和后移，属于双向迭代器。

list 的特点：

(1) 不使用连续的内存空间这样可以随意地进行动态操作；
(2) 可以在内部任何位置快速地插入或删除，当然也可以在两端进行push 和pop 。
(3) 不能进行内部的随机访问，即不支持[ ] 操作符和vector.at() ；
(4) 相对于verctor 占用更多的内存。

1.list构造函数

list<int> values;
list<int> values(10);          //默认10个0
list<int> values(10, 5);       //默认10个5
list<int> value2(value);       //拷贝构造
list<int> value2(value.begin(),value.end());   //迭代器构造

2.list赋值和交换

//成员函数
list<int> list1(10,4);
list<int> list2;
list2.assign(list1.begin(),list.end());
//重载了=
list2=list1;
//交换，两个链表之间的交换
list2.swap(list1);

3.大小操作

//成员函数
list<int> c(10,5);
c.size()     //容器中的元素个数
c.empty()    //是否为空
c.resize(num)   //重新指定容器的长度为num，如果变长，就以默认值填充，如果指定默认值，就在后边加个参数；如果变短，末尾超出的元素就会被删除

 4.插入或者删除元素

push_back(elem);               //在容器尾部加入一个元素
pop_back();                    //删除容器中最后一个元素
push_front(elem);              //在容器开头插入一个元素
pop_front();                   //从容器开头移除第一个元素
insert(pos,elem);              //在pos位置插elem元素的拷贝，返回新数据的位置。
insert(pos,n,elem);            //在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end);           //在pos位置插入[beg,end)区间的数据，无返回值。
clear();                       //移除容器的所有数据
erase(beg,end);                //删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);                    //删除pos位置的数据，返回下一个数据的位置。
remove(elem);                  //删除容器中所有与elem值匹配的元素

 insert的示例

#include<iostream>
#include<string>
#include<list>
using namespace std;

//队列不提供迭代器，更不支持随机访问


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


void test()
{
	list<int> c1;
	for (int i = 0; i != 5; i++) {
		c1.push_back(i);
	}
	// 0 1 2 3 4
	list<int>::iterator it = c1.begin();
	c1.insert(it, 10);//一定要注意返回值，此时it的指向,it指向的还是0（旧链表）；
	Print(c1);//10 0 1 2 3 4
	c1.insert(it++, 100);
	Print(c1);//10 100 0 1 2 3 4（it指向1）
	c1.insert(it, 2, 20);
	Print(c1);//10 100 0 20 20 1 2 3 4(it指向1)  
	cout << (*it) << endl;
	//只要不重新构建新的迭代器，这个it只负责原来的list

	
	
	//c1.erase(it); //删除了2这个元素，然后it也随之删除，建议用
	c1.erase(it++);
	Print(c1);//10 100 0 20 20 2 3 4 （it）指向2
	cout << (*it) << endl;
	//c1.erase(++it);//已经被删除了，还怎么++
	/*cout << (*it) << endl;*/


	//这里“++”运算符与我们平常的理解刚好相反，erase(itList++) 是先获取下一个元素的位置再删除； erase(++itList) 是删除以后再获取下一个元素的位置。
}


int main()
{
	test();
	return 0;
	system("pause");
}

 5.数据存取

//成员函数
list<int> c(10,5);
c.front();    //返回第一个元素
c.back();     //返回第二个元素
//不能通过[]或者at方式访问

 6.反转和排序

//成员函数
list<int> c(10,5);
c.reverse();    //反转容器的元素
c.sort();     //默认是从大到小排序，这里不要通过algorithm中的sort去排序，list提供了一个重载版本
//原因在于list的内存空间不是连续的
//标准库算法中的操作需要随机访问迭代器，也就是支持[]或at的

#include<iostream>
#include<string>
#include<list>
using namespace std;

template<class T>
void Print(const T & my)
{
	for (T::const_iterator it=my.begin();it!=my.end();it++)
	{
		cout << (*it) << " ";
	}
	cout << endl;
}

static bool cmp(const int& a, const int& b)
	{
		return a > b;//重点看a>b就是降序排列
	}


void test()
{
	list<int> v;
	v.push_back(7);
	for (int i = 1; i < 6; i++)
	{
		v.push_back(i);
	}
	Print(v);
	v.sort();//默认升序的方法
	//由于sort是标准库算法，是需要随机迭代器访问的，也就是支持[]和at的 
	Print(v);// 1 2 3 4 5 7
	v.sort(cmp);//自定义排序方式，也就是逆序排列
	Print(v);
}
//sort中的比较函数compare要声明为静态成员函数或全局函数，不能作为普通成员函数，否则会报错。这是 因为：非静态成员函数是依赖于具体对象的，
//而std::sort这类函数是全局的，因此无法在sort中调用非静态成员函数。静态成员函数或者全局函数是不依赖于具体对象的, 可以独立访问，无须创建任何对象实例就可以访问。
//同时静态成员函数不可以调用类的非静态成员。

int main()
{
	test();
	return 0;
	system("pause");
}

 7.合并与拼接

1）merge()是将两个有序的链表合并成另一个有序的链表，如果有一个链表不是有序的那么在执行代码时会报错：说链表不是有序的。

2）还有，两个链表中的内容排序顺序与合并时采用的排序顺序必须一致，如果不一致，也会报错，说链表不是有序的。如想要降序合并两个链表，那么合并前的两个链表也必须是按降序排列的。

3）另外，当执行完merge()后，右边的链表将变为空。

4）这里也必须要使用merge成员函数，而不能使用algorithm中的merge算法。

list<int> v1, v2;

v2.merge(v1); //按照默认排序方法合并，即按照升序
//v1和v2必须要是升序，否则会报错
v2.merge(v1,greater<int>()); //按照降序合并

splice（）单纯的合并 

 list::splice实现list拼接的功能。将源list的内容部分或全部元素删除，拼插入到目的list。

void splice ( iterator position, list<T,Allocator>& x );  

void splice ( iterator position, list<T,Allocator>& x, iterator it );

void splice ( iterator position, list<T,Allocator>& x, iterator first, iterator last );

position 是要操作的list对象的迭代器（在何处进行插入合并）

list<T Allocator>&x 被剪的对象

1.会在position后把list<T Allocator>&x所有的元素到剪接到要操作的list对象

2.只会把list<T Allocator>&x 的it的值剪接到要操作的list对象中

3.把first 到 last 剪接到要操作的list对象中

8. 元素去重

       unique函数属于STL中比较常用函数，它的功能是元素去重。即”删除”序列中所有相邻的重复元素(只保留一个)。此处的删除，并不是真的删除，而是指重复元素的位置被不重复的元素给占领了(详细情况，下面会讲)。由于它”删除”的是相邻的重复元素，所以在使用unique函数之前，一般都会将目标序列进行排序。

#include<iostream>
#include<string>
#include<list>
using namespace std;

template<class T>
void Print(const T & my)
{
	for (T::const_iterator it=my.begin();it!=my.end();it++)
	{
		cout << (*it) << " ";
	}
	cout << endl;
}

void test()
{
	list<int> v;
	v.push_back(7);
	v.push_back(4);
	v.push_back(4);
	for (int i = 1; i < 6; i++)
	{
		v.push_back(i);
	}
	v.push_back(4);
	Print(v);
	v.sort();
	Print(v);
	v.unique();//你如果不排序，只能删除目前相邻的重复元素，只有排序之后才能删除里边的全部重复元素。这个可与set容器不一样，set至少保留一个元素
	//unique是全局算法，但是对于这种list的双向非随机迭代器，就需要利用重载的成员函数，真正实现去重
	Print(v);
}

int main()
{
	test();
	return 0;
	system("pause");
}

9.list常用的成员函数一览表

成员函数	功能
begin()	返回指向容器中第一个元素的双向迭代器。
end()	返回指向容器中最后一个元素所在位置的下一个位置的双向迭代器。
rbegin()	返回指向最后一个元素的反向双向迭代器。
rend()	返回指向第一个元素所在位置前一个位置的反向双向迭代器。
cbegin()	和 begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
cend()	和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
crbegin()	和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
crend()	和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
empty()	判断容器中是否有元素，若无元素，则返回 true；反之，返回 false。
size()	返回当前容器实际包含的元素个数。
max_size()	返回容器所能包含元素个数的最大值。这通常是一个很大的值，一般是 232-1，所以我们很少会用到这个函数。
front()	返回第一个元素的引用。
back()	返回最后一个元素的引用。
assign()	用新元素替换容器中原有内容。
emplace_front()	在容器头部生成一个元素。该函数和 push_front() 的功能相同，但效率更高。
push_front()	在容器头部插入一个元素。
pop_front()	删除容器头部的一个元素。
emplace_back()	在容器尾部直接生成一个元素。该函数和 push_back() 的功能相同，但效率更高。
push_back()	在容器尾部插入一个元素。
pop_back()	删除容器尾部的一个元素。
emplace()	在容器中的指定位置插入元素。该函数和 insert() 功能相同，但效率更高。
insert()	在容器中的指定位置插入元素。
erase()	删除容器中一个或某区域内的元素。
swap()	交换两个容器中的元素，必须保证这两个容器中存储的元素类型是相同的。
resize()	调整容器的大小。
clear()	删除容器存储的所有元素。
splice()	将一个 list 容器中的元素插入到另一个容器的指定位置。
remove(val)	删除容器中所有等于 val 的元素。
remove_if()	删除容器中满足条件的元素。
unique()	删除容器中相邻的重复元素，只保留一个。
merge()	合并两个事先已排好序的 list 容器，并且合并之后的 list 容器依然是有序的。
sort()	通过更改容器中元素的位置，将它们进行排序。
reverse()	反转容器中元素的顺序。