list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向 其前一个元素和后一个元素。

支持++ -- 但是不支持+和-

 list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。

list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向 其前一个元素和后一个元素。

链表的主流访问方式就是迭代器

list构造  

1） 空容器构造函数（默认构造函数）

构造一个没有元素的空容器。

（2） 填充构造函数

构造一个包含 n 个元素的容器。每个元素都是 val 的副本。

（3） 范围构造函数

构造一个容器，其中包含与范围 [first，last] 一样多的元素，每个元素都按相同的顺序从该区域中的相应元素构造。

（4） 复制构造函数

以相同的顺序构造一个容器，其中包含 x 中每个元素的副本。

int main()
{
	
	std::list<int> first;                   //空构造           
	std::list<int> second(4, 100);                  //4个值为100的构造   
	std::list<int> third(second.begin(), second.end()); //范围构造
	std::list<int> fourth(third);                      //拷贝构造

	
	int myints[] = { 16,2,77,29 };
	std::list<int> fifth(myints, myints + sizeof(myints) / sizeof(int));//也可以使用其他容器进行范围构造

	std::cout << "The contents of fifth are: ";
	for (std::list<int>::iterator it = fifth.begin(); it != fifth.end(); it++)
		std::cout << *it << ' ';

	std::cout <<endl;

	return 0;
}

void list1()
{
	list<int>l1 = { 1,2,3,4,5,6 };
	list<int>::iterator it = l1.begin();
	while(it != l1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;

}

list迭代器

list的begin()指向头结点的下一个结点 也就是第一个有效元素的结点  end()指向头节点 也就是最后有效元素的下一个结点   rbegin()指向头结点   rend()指向头节点的下一个结点

list的成员函数empty是检测链表是否为空 并且返回布尔值  若为空 返回1 若不为空 返回0

返回链表容器中的元素数

front 和back 分别返回链表的第一个有效元素 和最后一个有效元素  有const和非const两个版本

list::push_front (const vallue_type & val)   list ::push_back(const value_type& val)

分别对链表进行头插 和尾插

list::pop_front ()   list ::pop_back()

分别对链表进行头删和尾删

（1）通过在指定位置插入单个元素

  (2)   通过在指定的位置插入 n个相同的val元素

（3）通过在指定的位置 范围插入一段内容

(1)在指定位置删除单个元素

(2)在指定的范围内删除所有元素

list无法使用alogrithm库 中的sort进行排序 

void list1()
{
	list<int>l1 = { 1,2,3,4,5,6 };
	list<int>::iterator it = l1.begin();
	while(it != l1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	sort(l1.begin(),l1.end());
}

原因是sort底层是快排 要使用随机迭代器 但是list是双向迭代器

那么链表如何排序呢

在链表的成员函数中存在专门为链表排序的sort成员函数

void list1()
{
	list<int>l1 = { 1,2,3,4,5,6 ,1,3,4};
	list<int>::iterator it = l1.begin();
	while(it != l1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	//sort(l1.begin(),l1.end());
	l1.sort();
	list<int>::iterator it1 = l1.begin();

	while (it1 != l1.end())
	{
		cout << *it1 << " ";
		it1++;
	}
}

这是默认升序 如果想要降序那么就要传仿函数作为参数进入

void list1()
{
	list<int>l1 = { 1,2,3,4,5,6 ,1,3,4};
	list<int>::iterator it = l1.begin();
	while(it != l1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	//sort(l1.begin(),l1.end());
	l1.sort();
	list<int>::iterator it1 = l1.begin();

	while (it1 != l1.end())
	{
		cout << *it1 << " ";
		it1++;
	}
	cout << endl;
	//greater<int>gt;
	l1.sort(greater<int>());
	for (auto e:l1)
	{
		cout << e << " ";
	}
	cout << endl;
}

在现在的链表中是存在重复的数据的 如果想要去重该如何

有专门的去重成员函数unique

void list1()
{
	list<int>l1 = { 1,2,3,4,5,6 ,1,3,4};
	list<int>::iterator it = l1.begin();
	while(it != l1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	//sort(l1.begin(),l1.end());
	l1.sort();
	list<int>::iterator it1 = l1.begin();

	while (it1 != l1.end())
	{
		cout << *it1 << " ";
		it1++;
	}
	cout << endl;
	//greater<int>gt;
	l1.sort(greater<int>());
	for (auto e:l1)
	{
		cout << e << " ";
	}
	cout << endl;
	l1.unique();
	for (auto e : l1)
	{
		cout << e << " ";
	}
	cout << endl;
}

但是list.sort排序的效率相较于快速排序的sort的效率还是非常低的 这点需要注意

拼接(转移)

接合

第一个版本 （1） 将 x 的所有元素传输到容器中。
第二个版本 （2） 仅将 i 指向的元素从 x 传输到容器中。
第三个版本 （3） 将范围 [first，last] 从 x 传输到容器中

void list2()
{

	std::list<int> mylist1, mylist2;
	std::list<int>::iterator it;

	// set some initial values:
	for (int i = 1; i <= 4; ++i)
		mylist1.push_back(i);      // mylist1: 1 2 3 4

	for (int i = 1; i <= 3; ++i)
		mylist2.push_back(i * 10);   // mylist2: 10 20 30

	it = mylist1.begin();
	++it;                         // points to 2

	mylist1.splice(it, mylist2); // mylist1: 1 10 20 30 2 3 4
	for (auto e:mylist1)
	{
		cout << e << " ";
	}
	cout << endl;
}

这里使用的是第一个版本 将lsit容器x的全部元素插入 到 mylist1的pos位置  且此时链表二中被转移的内容是不会在存在在链表二的 相当于是转移

链表中不存在find 所以想要使用find需要使用算法库中的find

第一个参数和第二个参数确定查找的范围 第三个元素是要查找的元素

void list3()
{
	list<int> mylist1;
	for (int i = 1; i <= 4; i++)
		mylist1.push_back(i);
	auto it = find(mylist1.begin(),mylist1.end(),3);
	mylist1.splice(mylist1.begin() , mylist1,it);
	for (auto e : mylist1)
	{
		cout << e << " ";
	}
	cout << endl;
}