list容器部分API

list容器是循环双链表,因为存储空间不连续，所以他的迭代器不支持随机访问，进行排序时不能使用algorithm 里的通用版全局sort，使用list自身定制版的成员函数sort进行排序.

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

//list是一个双向循环链表，第一个节点的pre指针域执向最后一个节点，最后一个节点的next指针域指向第一个节点
//可以在两端进行插入和删除
//存储空间不连续，迭代器只能前移递增(++)和后移递减(--)，不能随机访问(跳跃访问)，属于双向迭代器

void printList(const list<int>& l) {
	//从前向后
	for (list<int>::const_iterator it = l.begin(); it != l.end(); ++it)
		cout << *it << " ";
	cout << endl;
	/*
	//从后向前逆序输出:反向迭代器
	for (list<int>::const_reverse_iterator it = l.rbegin(); it != l.rend(); ++it)
		cout << *it << " ";
	*/
}

//构造器
/*
默认构造:list<T> 
n个elem来初始化:list<T> l(n,elem)
拷贝构造:list<T> l2(l1)   //用对象l1调用拷贝构造函数构造l2
区间构造:list<T> l(start,end) //用[start,end)区间的元素构造l
*/
void test01() {
	list<int> l;  //1.默认构造
	l.emplace_back(10);
	l.emplace_front(20); 
	l.emplace_front(300);
	l.emplace_back(400);

	//内存不连续，非数组实现，不能重载[]和使用at访问
	/*for (int i(0); i < l.size(); ++i)
		cout << l[i] << " " << l.at(i) << endl;*/ 
	printList(l);

	int n(10);
	list<int> l2(n, 100);  //2.n个100构造
	printList(l2);

	list<int> l3(l); //3.拷贝构造
	printList(l3);
	list<int> l4(l.begin(), l.end());//4.区间构造
	printList(l4); 
}

//赋值和交换
//list里使用swap函数交换两个链表
void test02() {
	//赋值
	list<int> l(4, 666);
	list<int> l2;
	l2 = l; //1.重载=赋值
	printList(l2);
	int n = 10;
	l2.assign(n, 404);  //2.n个400赋值给l2
	printList(l2);
	l2.assign(l.begin(), l.end());  //3.区间赋值
	printList(l2);

	cout << "-----------交换------------" << endl;
	//交换
	list<int> l3(n, 233);
	printList(l3);
	l.swap(l3);     //将链表l与链表l3进行交换
	printList(l3);
}

//大小操作
void test03() {
	list<int> l;
	l.emplace_back(100);
	l.push_back(200);
	l.emplace_back(300);

	if (!l.empty())  //判断是否为空
		cout << "大小:" << l.size() << endl;  //获取大小
	else cout << "空链表" << endl;

	//重新指定大小
	printList(l);
	l.resize(8);  //扩大空间，新增的空间默认用0填充     
	printList(l);
	l.resize(10, 333); //使用333填充新增空间
	printList(l);
	l.resize(2);     //缩小空间，多余的空间舍弃
	printList(l);
}

//插入
/*
1.两端插入
	尾插:emplace_back/push_back
	头插:emplace_front/push_front
2.任意位置emplace/insert
	emplace(pos,elem) //在迭代器位置pos插入一个elem
	insert(pos,elem)  //在pos位置插入一个elem
	insert(pos,n,elem) //在pos位置插入n个elem
	insert(pos,start,end)  //在pos位置插入迭代器区间[start,end)内的所有元素
*/
void test04() {
	list<int> l;
	l.emplace_back(10);
	l.push_back(20);
	l.emplace_front(30);
	l.push_front(40);
	printList(l);
	l.emplace(l.begin(), 1000);  //头插
	l.insert(l.end(), 3000);  //尾插
	printList(l);
	l.insert(l.begin(), 2, 666);   //在头部插入2个666
	printList(l);
	list<int> l2(2, 999);
	l.insert(l.end(), l2.begin(), l2.end());  //在l尾部插入l2的所有元素
	printList(l);
}

//删除
/*
1.两端：
	尾部删除：pop_back()
	头部删除：pop_front()
2.使用迭代器:
	erase(pos) //删除迭代器pos位置的元素
	erase(start,end) //删除迭代器区间[start,end)内的所有元素
3.删除所有指定值
	remove(elem) //删除链表里所有的elem
4.清空:clear()
*/
void test05() {
	list<int> l;
	for (int i(0); i < 5; ++i)
		l.emplace_back(i + 1);
	printList(l);
	l.pop_back(); 
	printList(l);
	l.pop_front();
	printList(l);
	l.erase(l.begin()); //删除第一个位置
	printList(l);
	//l.erase(l.end()); //end为最后一个元素的下一个位置，删除不合法
	//printList(l);
	l.erase(l.begin(), l.end());  //区间删除
	if (l.empty())
		cout << "空链表" << endl;
	else printList(l);

	list<int> l2;
	l2.emplace_back(100);
	l2.emplace_front(200);
	l.emplace_front(100);
	l2.emplace_back(300);
	l2.emplace_back(100);
	printList(l2);
	l2.remove(100);
	printList(l2);
	l2.clear();
}

//数据存取:可以操作第一个元素和最后一个元素
void test06() {
	list<int> l;
	for (int i(0); i < 5; ++i)
		l.emplace_front(i+10);
	cout << "第一个元素:" << l.front() << endl;
	cout << "最后一个元素:" << l.back() << endl;
	l.front() = 235;   //修改第一个元素的值
	l.back() = 3000;
	cout << "第一个元素:" << l.front() << endl;
	cout << "最后一个元素:" << l.back() << endl;

	//验证迭代器不支持随机访问
	list<int>::iterator it(l.begin());
	++it;
	--it;
	//it = it + 1;  //错误，没有重载+，就不是随机访问任何合法位置的元素
	
}

bool myCompare(int a, int b) {
	return a > b; //降序
}
void test07() {
		list<int> l;
	for (int i(0); i < 10; ++i)
		l.emplace_back(i);
	cout << "反转前:" << endl;
	printList(l);
	l.reverse();    //自带成员函数
	cout << "反转后:" << endl;
	printList(l);

	//对于不支持随机访问的迭代器的容器（存储空间不连续），不能使用标准通用的全局排序函数
	//需要定制版的sort
	l.sort();    //定制成员函数排序
	cout << "升序排序后:" << endl;
	printList(l);
	cout << "降序排序后:" << endl;
	l.sort(myCompare);
	printList(l);
}

//合并
void test08() {
	int n(4);
	list<int> l1(n, 10);
	list<int> l2(n, 20);
	l1.merge(l2);    //使用自带成员函数合并,将链表l2合并到l1
	cout << "l1:";
	printList(l1);
	if (l2.empty())
		cout << "合并后，被合并的链表设置为空" << endl;
	else {
		cout << "l2:";
		printList(l2);
	}
}
int main() {
	/*cout << "***************构造函数*************" << endl;
	test01();*/
	/*cout << "***************赋值和交换*************" << endl;
	test02();*/
	/*cout << "***************大小操作*************" << endl;
	test03();*/
	/*cout << "***************插入*************" << endl;
	test04();*/
	/*cout << "***************删除*************" << endl;
	test05();*/
	/*cout << "***************访问数据*************" << endl;
	test06();*/
	/*cout << "***************反转和排序*************" << endl;
	test07();*/
	cout << "***************合并*************" << endl;
	test08();

	return 0;
}

补充：合并两个链表可使用merge和splice.