list---list的介绍及使用

list介绍

1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代；
2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素；
3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效；
4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好；
5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)。

list的实现方式：

和之前写的string，vector实现方式类似，这里不做讲解：

void test()
{
	list<int> lst;
	list<char> lst2;

	list<int> lst3(3, 5);
	string str = "123456";
	list<char> lst4(str.begin(), str.end());
	char arr[] = "abcde";
	list<char> lst5(arr, arr + sizeof(arr) / sizeof(arr[0]));

	vector<char> v(str.begin(), str.end());
	list<char> lst6(v.begin(), v.end());
}

读取list元素：

以下代码都是通过迭代器实现读取：
分别包括正向迭代器、正向只读迭代器、反向迭代器、反向只读迭代器（正向回退：一般不会这么用）。

void test()
{
	string s = "12345";
	list<char> lst(s.begin(), s.end());
	//正向迭代器
	//可读可写
	list<char>::iterator it = lst.begin();
	while (it != lst.end())
	{
		cout << *it << " ";
		*it = 'a';
		++it;
	}
	cout << endl;

	//const正向迭代器，不支持改写操作，只支持读
	list<char>::const_iterator cit = lst.cbegin();
	while (cit != lst.cend())
	{
		cout << *cit << " ";
		++cit;
	}
	cout << endl;

	//反向迭代器
	list<char> lst2(s.begin(), s.end());
	list<char>::reverse_iterator rit = lst2.rbegin();
	while (rit != lst2.rend())
	{
		cout << *rit << " ";
		*rit = 'c';
		++rit;
	}
	cout << endl;

	//反向只读迭代器向后回退(反向迭代器正向输出)：
	//crbegin是最后一个元素位置,crend是第一个元素的前一位置
	list<char> lst3(s.begin(), s.end());
	list<char>::const_reverse_iterator crit = lst3.crend();
	//现在要从第一个元素向后遍历，先让crit指向第一个元素位置
	--crit;
	while (crit != lst3.crbegin())
	{
		cout << *crit << " ";
		--crit;
	}
	//由于while循环中未能遍历所有位置，最后一个crbegin上的元素需要单独进行输出
	cout << *crit;
	cout << endl;


}

范围for：底层通过迭代器实现
一般都是通过引用接收，如果用值来接收的话，内置类型没什么问题，如果是自定义类型的话容易发生拷贝操作，效率低下，如果自定义类型还有资源的话则效率更加低下。

	//范围for
	for (auto&e : lst3)
	{
		cout << e << " ";
		e = 'c';
	}
	cout << endl;

	for (const auto&e : lst3)
	{
		cout << e << " ";
	}
	cout << endl;

list一些函数操作：

头插尾插以及迭代器失效问题逐行解释。

void test()
{
	list<int> lst;
	lst.push_front(1);
	lst.push_back(2);
	//进行头插操作
	lst.insert(lst.begin(), 0);
	//获取迭代器
	list<int>::iterator it = lst.begin();
	cout << *it << endl;
	//进行尾插操作
	lst.insert(lst.end(), 3);
	//自定义类型才能体现优势：emplace
	lst.emplace(lst.begin(), -1);
	lst.emplace_back(4);
	lst.emplace_front(-2);
	//insert也可以插入一个区间：但是不能用自己本身迭代器的区间，因此拷贝一个进行插入
	list<int> copy = lst;
	lst.insert(lst.end(), copy.begin(), copy.end());
	//范围for进行遍历
	for (const auto&e : lst)
	{
		cout << e << " ";
	}
	cout << endl;
	//插入不会导致迭代器失效
	//插入不会释放原有元素空间，因为没有增容操作，相当于开了一个新元素空间，把元素放到空间中，再进行链接
	cout << *it << endl;

	//删除会导致迭代器失效
	//该空间已经不属于当前list：删除该节点后，后一个节点与前一个节点链接起来
	//不能解引用
	//lst.erase(it);
	//cout << *it << endl;

	//删除操作后如果想继续使用：重新获取
	//erase返回值：迭代器->被删除元素的下一个元素位置
	it = lst.erase(it);
	cout << *it << endl;

	//resize操作
	//元素个数调整到5个，如果有增加位置则赋值100
	lst.resize(5, 100);
	//元素个数调整到7个，增加的两个元素值为200
	lst.resize(7, 200);
}

list拼接、删除、去重、合并操作：

template <class T>
void printList(const list<T>& lst)
{
	for (const auto& e : lst)
		cout << e << " ";
	cout << endl;
}

void test()
{
	string s = "123";
	string s2 = "abc";
	list<char> lst(s.begin(), s.end());
	list<char> lst2(s2.begin(), s2.end());
	//拼接操作：splice(iterator position(指定拼接位置)，list& x(拼接内容))
	//给lst前面放入lst2的所有元素
	lst.splice(lst.begin(), lst2);
	//也可以指定区间，只把b c 拼接过去
	//lst.splice(lst.begin(),lst2, ++lst2.begin(),lst2.end());
	printList(lst);
	//打印内容：a b c 1 2 3
	//被拼接的lst2被直接拿过去而不是拷贝过去，lst2的内容变空了
	printList(lst2);
	//打印内容：

	//删除操作：如果值不存在则不进行操作
	lst.remove('f');
	printList(lst2);

	//unique:删除重复元素(只能去重相邻元素重复)
	lst.push_back('1');
	lst.push_back('1');
	lst.push_back('3');
	//unique:在数据有序的情况下，进行元素的去重
	lst.unique();
	printList(lst);
	//因此先进行排序再进行去重
	//sort:由小到大排序
	lst.sort();
	printList(lst);
	lst.unique();
	printList(lst);

	int arr[] = { 10,3,2,9 };
	int arr2[] = { 10,13,21,29 };
	list<int> lst3(arr, arr + 4);
	list<int> lst4(arr2, arr2 + 4);
	//merge：合并，需要数据有序情况下进行合并
	lst3.sort();
	lst4.sort();
	lst3.merge(lst4);
	printList(lst3);
}