list双向链表容器

list容器实现了双向链表的数据结构，数据元素是通过链表指针串联成逻辑意义上的线性表，因此对链表的任一位置的元素进行插入、删除和查找都是极快的。

list每个节点有三个域：前驱元素指针域、数据域、后继元素指针域，list的头结点的前驱元素指针域保存的是链表中尾元素的首指针，而list的尾节点的后继元素指针域则保存了头结点的首指针，这样构成了一个双向循环链表。

由于list对象节点并不要求在一段连续的内存中，所以对于迭代器，只能通过“++"和”--“的操作将迭代器移动到后继/前驱节点元素处。而不能对迭代器进行+n或者-n操作，这点是与vector等不同的地方。

使用list需要包含头文件：#include<list>

创建list对象

（1）创建空链表

list<int> l;

（2）创建具有n个元素的链表

list<int> l(10);

（3）创建具有初值的n个元素的链表

list<int> l(10,5);

元素插入和遍历

使用push_back()方法往尾部插入新元素，push_front()方法往首部插入新元素，insert()方法往迭代器位置插入新元素，链表自动扩张。

注意，迭代器只能采用"++"或者“--”操作，不能进行+n或者-n操作，因为各节点之间在物理上并不是顺序存储的，并且指向链表元素的迭代器之间也没有大小关系。

#include<list>
#include<iostream>
using namespace std;
int main()
{
list<int> l;
l.push_back(2);
l.push_back(3);
l.push_back(5);

l.push_front(1);

list<int>::iterator it = l.begin();
it++;
l.insert(++it,20);
//迭代器之间没有大小关系，所以使用不等号
for(it=l.begin();it!=l.end();it++)
{
cout<<*it<<" ";
}
return 0;
}

输出结果：

1 2 20 3 5

反向遍历

采用反向迭代器reverse_iterator对链表进行反向遍历，使用方法和deque反向遍历的方法一样

#include<list>
#include<iostream>
using namespace std;
int main()
{
list<int> l;
for(int i=1;i<10;i++)
l.push_back(i);

list<int>::reverse_iterator rit;
for(rit=l.rbegin();rit!=l.rend();rit++)
{
cout<<*rit<<" ";
}
return 0;
}

输出结果：9 8 7 6 5 4 3 2 1

元素删除

（1）使用remove()方法删除链表中的一个值，所有元素值等于该值的元素都会被删除。

（2）使用pop_front()方法删除链表首元素，使用pop_back()方法删除链表尾元素。

（3）使用erase()方法删除迭代器位置上的元素

（4）使用clear()方法清空链表

#include<list>
#include<iostream>
using namespace std;
void Show(list<int> &l)
{
list<int>::iterator it;
for(it=l.begin();it!=l.end();it++)
cout<<*it<<" ";
cout<<endl;
}
int main()
{
list<int> l;
list<int>::iterator it;

for(int i=1;i<10;i++)
l.push_back(i);
Show(l);

l.pop_back();
l.pop_front();
Show(l);

it = l.begin();
l.insert(++it,5);
l.insert(++it,5);
Show(l);

l.remove(5);
Show(l);

l.erase(it);
Show(l);

l.clear();
cout<<l.size()<<endl;

return 0;
}

输出结果：

1 2 3 4 5 6 7 8 9

2 3 4 5 6 7 8

2 5 3 5 4 5 6 7 8

2 3 4 6 7 8

2 3 6 7 8

0

元素查找

采用find()查找算法可以在链表中查找元素，如果找到该元素，则返回的是该元素迭代器的位置，如果找不到则返回end()迭代器的位置。

find()算法需要声明头文件包含：#include<algorithm>

#include<list>
#include<algorithm>
#include<iostream>
using namespace std;
void Show(list<int> &l)
{
list<int>::iterator it;
for(it=l.begin();it!=l.end();it++)
cout<<*it<<" ";
cout<<endl;
}
int main()
{
list<int> l;
list<int>::iterator it;

for(int i=1;i<10;i++)
{
l.push_back(i);
}
Show(l);

it = find(l.begin(),l.end(),5);
if(it!=l.end())
cout<<"find 5"<<endl;
else
cout<<"not find 5"<<endl;

it = find(l.begin(),l.end(),10);
if(it!=l.end())
cout<<"find 10"<<endl;
else
cout<<"not find 10"<<endl;

return 0;
}

输出结果：

1 2 3 4 5 6 7 8 9

find 5

not find 10

元素排序

使用sort()方法对元素进行排序，默认情况先，sort函数中没有参数，为升序排序，我们可以通过构造函数comp作为sort方法的参数，实现升序排序。

#include<list>
#include<iostream>
using namespace std;
void Show(list<int> &l)
{
list<int>::iterator it;
for(it=l.begin();it!=l.end();it++)
cout<<*it<<" ";
cout<<endl;
}
bool comp(int a,int b)
{
return a>b;
}
int main()
{
list<int> l;
list<int>::iterator it;

for(int i=10;i>0;i--)
{
l.push_back(i);
}
Show(l);
//升序排序
l.sort();
Show(l);
//降序排序
l.sort(comp);
Show(l);

return 0;
}

剔除重复的元素

使用unique()方法可以提出连续重复元素，只保留一个。

注意remove()方法和unique方法的区别，remove是删除list中所有元素为该值得节点，而unique是对于连续重复节点，只保留一个。

#include<list>
#include<iostream>
using namespace std;
void Show(list<int> &l)
{
list<int>::iterator it;
for(it=l.begin();it!=l.end();it++)
cout<<*it<<" ";
cout<<endl;
}
int main()
{
list<int> l;
list<int>::iterator it;

for(int i=5;i>0;i--)
{
l.push_back(i);
}
Show(l);

l.push_front(1);
l.push_front(1);
l.push_front(1);
Show(l);

l.unique();
Show(l);

return 0;
}

输出结果：

5 4 3 2 1

1 1 1 5 4 3 2 1

1 5 4 3 2 1