stl之list双向链表容器应用基础

不一样于採用线性表顺序存储结构的vector和deque容器。list双向链表中任一位置的元素差值、插入和删除，都具备高效的常数阶算法时间复杂度O(1)。

头文件

#include<list>

建立list对象

1)list();//建立一个没有不论什么元素的list对象。

list<int>l 

2)list(size_type n);// 建立一个具备 n 个元素的 list 对象，每个元素採用它的类型下的默认值。

list<int>l(10);//list对象l有10个元素。每个元素初始值为。

3)list<size_type n, constT& value); // 建立一个具备 n 个元素的 list 对象，这些元素的初始值为 value 。

list<double>l(10,5.6); 

4)list(const list&);//list 的拷贝构造函数，经过拷贝一个 list 对象的元素值，建立一个新的 list 对象。

list<char>l1(5,’a’); 
list<char>l2(l1); 

5)list(const InputIterator first, const InputIterator last,const A& a=A());

//将迭代区间[first,last)所指的元素复制到一个新建立的list对象中。当中内存分配器可缺省。

//利用int数组iArray，建立一个list对象l 
intiArray[]={1,2,3,4,5,6,7}; 
list<int>l(iArray, iArray+7); // 建立list对象

初始化赋值

利用list提供的push_back函数，可将元素依次链入链表中。push_back函数常用于list容器的初始化。

元素的遍历訪问

由于链表中元素需要一个个元素遍历，所以，list元素的遍历仅仅能使用迭代器的方式进行。

#include <iostream>
#include <list>
using namespace std;
int main ()
{
	int Array[] = {16,2,77,29};
	//用上面第五种方式建立list对象
	list<int> mylist(Array,Array+sizeof(Array)/sizeof(int));
	//遍历输出
	for (list<int>::iterator it = mylist.begin(); it != mylist.end(); it++)
		std::cout << *it << ' ';
	std::cout << '\n';
	return 0;
}

list链表元素的插入

由于list链表元素的插入不需要对其它元素进行移位拷贝。所以list元素的插入函数是有常数阶的O(1)算法时间复杂度。

voidpush_front(constT&);//头部插入

iteratorinsert(iterator pos, const T& x);//pos位置以前，插入新元素x

详细实例与前篇deque的应用类似。这里再也不多说。

list链表元素的删除

list相同具备高效的链表元素删除处理。包含删除首元素pop_front函数、删除尾元素的pop_back函数，删除任何位置或迭代区间上元素的erase函数。以及删除所有元素的clear函数。

1)void pop_front();//删除 list的第一个链表元素

2)void pop_back();//删除 list的最后一个链表元素

3)iteratorerase(iterator pos);//删除 pos所指向的链表元素

4)iteratorerase(iterator first, iterator last);//删除迭代器区间 [first, last)所指向的所有链表元素

5)void clear();//删除所有 list链表元素

6)void remove(constT& value);//删除 list链表中所有元素值为 value的元素

详细实例与前篇deque的应用类似，这里再也不多说。

list链表的归并

list 链表元素的排序。是将 list链表切割成若干部分进行子排序，而后经过归并处理，实现 list的所有元素的排序。为此，list容器提供了 splice和 merge归并函数。

1)void splice(iterator position, list& x);//将 x的链表归并到当前 list链表的 position位置以前。 list对象 x将被清空

void splice(iterator position, list& x, iterator i);//将一个 list的迭代器 i 值所指的元素。归并到当前 list列表中。并将被归并的元素从原链表中删除。

void merge(list& x);//将list对象 x的链表归并到当前 list链表中，并清空 x的链表。

从merge 函数的源代码可看出。仅仅有当前 list链表和被归并的 x链表的元素，均预先依照元素值的 "<"关系排好，merge函数才具备意义，归并后的链表元素也是按 "<"关系排序的。

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

void print(list<int>& l);
int main()
{
	list<int> l;
	list<int> carry;
	for (int j=1; j<=10; j++)
	{
		l.push_back(j);
	}
	// splice() 函数
	carry.splice(carry.begin(), l, ++l.begin());
	// 打印carry
	cout << "carry 的链表元素为: ";
	print(carry);
	// 打印l
	cout << "l 的链表的元素为：";
	print(l);
	// merge() 函数使用方法
	list<int> x;
	x.push_back(30);
	x.push_back(31);
	x.push_back(32);
	l.merge(x);
	// 打印x
	cout << "x 的链表元素为空";
	print(x);
	// 打印l
	cout << "l 的链表元素为：";
	print(l);
	return 0;
}
// list 链表打印
void print(list<int>& l)
{
	list<int>::iterator i, iend;
	iend = l.end();
	for (i=l.begin(); i!=iend; ++i)
		cout << *i << ' ';
	cout << endl << endl;
}

list的元素排序

list 提供的 void sort函数。按 "<"关系进行 list链表元素排序，较小的元素排在前面。

#include <list>
#include <iostream>
using namespace std;
void print(list<int>& l);

int main()
{
	list<int> l;  
	for(int j=18; j>=0; j--)
		l.push_back(j);
	cout << "排序前: " ; print(l);
	//调用list<int>::sort()函数排序
	l.sort();
	cout << "排序后: " ; print(l);
	return 0;
}
void print(list<int>& l)
{
	list<int>::iterator i,iend;
	iend=l.end();
	for(i=l.begin(); i!=iend; i++)
		cout << *i << ' ';
	cout << endl;
}

list的连续反复元素的剔除

利用 list 提供的 void unique函数，可将连续反复的元素删除。仅保留一个。

#include <list>
#include <iostream>
using namespace std;
int main(void)
{ 
	list<int> l;
	l.push_back(6); 
	l.push_back(8);
	l.push_back(6);
	l.push_back(6);
	l.push_back(6);
	l.push_back(9);
	l.push_back(13);
	l.push_back(6);
	l.unique();
	list<int>::iterator i,iend;
	iend=l.end();
	for(i=l.begin(); i!=iend; i++)
		cout << *i << ' ';
	cout << endl;
	return 0;
}

此文为本人原创，转载请注明出处： http://blog.csdn.net/lsh_2013/article/details/46742541