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