---

一.list的使用

1.1list的构造

list (size_type n, const value_type& val = value_type()) 构造的list中包含n个值为val的元素

list() 构造空的list

list (const list& x) 拷贝构造函数

list (InputIterator first, InputIterator last) 用[first, last)区间中的元素构造list

1.2 list iterator的使用

此处，大家可暂时将迭代器理解成一个指针，该指针指向list中的某个节点。

begin + end 返回第一个元素的迭代器+返回最后一个元素下一个位置的迭代器

rbegin + rend 返回第一个元素的reverse_iterator,即end位置，返回最后一个元素下一个位置的reverse_iterator,即begin位置

【注意】

1. begin与end为正向迭代器，对迭代器执行++操作，迭代器向后移动

2. rbegin(end)与rend(begin)为反向迭代器，对迭代器执行++操作，迭代器向前移动

1.3 list capacity

empty 检测list是否为空，是返回true，否则返回false

size 返回list中有效节点的个数

1.4 list element access

front 返回list的第一个节点中值的引用

back 返回list的最后一个节点中值的引用

1.5 list modifiers

push_front 在list首元素前插入值为val的元素

pop_front 删除list中第一个元素

push_back 在list尾部插入值为val的元素

pop_back 删除list中最后一个元素

insert 在list position 位置中插入值为val的元素

erase 删除list position位置的元素

swap 交换两个list中的元素

clear 清空list中的有效元素

---

二.其他接口

必须是两个有序的list

list不能用算法库里面的sort

迭代器功能：iterator，const iterator，reverse iterator

性质：

算法提供的接口里面的迭代器名字提示可以用什么类型的迭代器

例如：若是提示使用双向迭代器，则随机迭代器和双向迭代器都能使用

list数据量小可以使用sort，数据量大能不用就不要用！！！

Release版本

Debug版本

Debug版本不能作为效率判定，因为包含了很多调试信息，如果要进行函数递归，消耗就比较大，所以我们不能用Debug版本，要用Release版本。

去重，只能去掉相连的数据，一般和sort连用

---

三.list的迭代器失效

前面说过，此处大家可将迭代器暂时理解成类似于指针，迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

---

四.list的模拟实现

list.h

#pragma once
#include<assert.h>
namespace Lee
{
	template<class T>
	struct list_node
	{
		list_node<T>* _next;
		list_node<T>* _prev;
		T _data;


		list_node(const T& x = T())
			:_next(nullptr)
			,_prev(nullptr)
			,_data(x)
		{

		}

	};

	template<class T,class Ref,class Ptr>
	struct list_iterator
	{
		typedef list_node<T> Node;
		typedef list_iterator<T, Ref, Ptr> Self;
		Node* _node;

		list_iterator(Node* node)
			:_node(node)
		{
		}

		Ref operator*()
		{
			return _node->_data;
		}

		Ptr operator->()
		{
			return &_node->_data;
		}


		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		Self operator++(int)
		{
			Self tmp(*this);
			_node = _node->_next;
			return tmp;
		}

		Self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		Self operator--(int)
		{
			Self tmp(*this);
			_node = _node->_prev;
			return tmp;
		}

		bool operator!=(const Self& it)
		{
			return _node != it._node;
		}

		bool operator==(const Self& it)
		{
			return _node == it._node;
		}

	};


	template<class T>
	class list
	{
		typedef list_node<T> Node;
	public:
		typedef list_iterator<T,T&,T*> iterator;
		typedef list_iterator<T,const T&,const T*> const_iterator;


		iterator begin()
		{
			return _head->_next;
		}

		iterator end()
		{
			return _head;
		}

		const_iterator begin() const
		{
			return _head->_next;
		}

		const_iterator end() const
		{
			return _head;
		}

		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;

			_size = 0;
		}

		list()
		{
			empty_init();
		}

		list(initializer_list<T> lt)
		{
			empty_init();
			for (auto& e : lt)
			{
				push_back(e);
			}
		}

		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}

		list(const list<T>& lt)
		{
			empty_init();
			for (auto e : lt)
			{
				push_back(e);
			}
		}

		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}

		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}

		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

		size_t size() const 
		{
			return _size;
		}

		void push_back(const T& x)
		{
			//Node* newnode = new Node(x);

			//Node* tail = _head->_prev;
			//newnode->_prev = tail;
			//tail->_next = newnode;
			//newnode->_next = _head;
			//_head->_prev = newnode;

			insert(end(), x);
		
		}

		void pop_back()
		{
			erase(--end());
		}

		void push_front(const T& x)
		{
			insert(begin(), x);
		}

		void pop_front()
		{
			erase(begin());
		}

		void insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;

			Node* newnode = new Node(x);
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			_size++;
		}

		iterator erase(iterator pos)
		{
			assert(pos != end());
			Node* cur = pos._node;
			Node* nextNode = cur->_next;
			Node* prevNode = cur->_prev;

			nextNode->_prev = prevNode;
			prevNode->_next = nextNode;

			delete cur;
			_size--;
			return iterator(nextNode);

		}

	private:
		Node* _head;
		size_t _size;
	};

}

---

五.list与vector的对比

vector与list都是STL中非常重要的序列式容器，由于两个容器的底层结构不同，导致其特性以及应用场景不同，其主要不同如下：

       1.vector                                      2.list

底层结构:
1.动态顺序表，一段连续空间
2. 带头结点的双向循环链表

随机访问:
1.支持随机访问，访问某个元素效率O(1)
2.不支持随机访问，访问某个元素效率O(N)

插入和删除:
1.任意位置插入和删除效率低，需要搬移元素，时间复杂度为O(N)，插入时有可能需要增容，增容：开辟新空间，拷贝元素，释放旧空间，导致效率更低
2.任意位置插入和删除效率高，不需要搬移元素，时间复杂度为O(1)

空间利用率:
1.底层为连续空间，不容易造成内存碎片，空间利用率高，缓存利用率高
2.底层节点动态开辟，小节点容易造成内存碎片，空间利用率低，缓存利用率低

迭代器:
1.原生态指针
2.对原生态指针(节点指针)进行封装

迭代器失效:
1.在插入元素时，要给所有的迭代器重新赋值，因为插入元素有可能会导致重新扩容，致使原来迭代器失效，删除时，当前迭代器需要重新赋值否则会失效
2.插入元素不会导致迭代器失效，删除元素时，只会导致当前迭代器失效，其他迭代器不受影响

使用场景:
1.需要高效存储，支持随机访问，不关心插入删除效率
2.大量插入和删除操作，不关心随机访问