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

转载于:https://www.cnblogs.com/zhezh/p/3773300.html