STL笔记_list

list：每次插入或删除一个元素，就配置或释放一个元素空间。对于任意位置的元素插入或元素移除，list永远是常数时间。

节点（node）

template<class T>
struct __list_node
{
	typedef void* void_pointer;
	void_pointer prev;//型别为void*，其实也可以设置为__list_node<T>*
	void_pointer next;
	T data;
};

这是一个双向链表。

迭代器

STL list是一个双向链表，迭代器必须具有前移、后移的能力，所以list提供的是Bidirectional Iterator。

list有一个重要性质：插入操作(insert)和接合操作(splice)都不会造成原有的list迭代器失效，甚至删除操作(erase)也只有指向被删除元素的那个迭代器失效。

template<class T,class Ref,class Ptr>
struct __list_iterator
{
	typedef __list_iterator<T, T&, T*> iterator;
	typedef __list_iterator<T, Ref, Ptr> self;

	typedef bidirectional_iterator_tag iterator_category;
	typedef T value_type;
	typedef Ptr pointer;
	typedef Ref reference;
	typedef __list_node<T>* link_type;
	typedef size_t size_type;
	typedef ptrdiff_t difference_type;

	link_type node;

	__list_iterator(link_type x):node(x){}
	__list_iterator(){}
	__list_iterator(const iterator& x):node(x.node){}

	bool operator==(const self& x)const { return node == x.node; }
	bool operator!=(const self& x)const { return node != x.node; }

	reference operator*()const { return (*node).data; }

	pointer operator->()const { return &(operator*()); }

	self& operator++() {
		node = (link_type)((*node).next);
		return *this;
	}
	self operator++(int) {
		self tmp = *this;
		++*this;
		return tmp;
}

	self& operator--() {
		node = (link_type)((*node).prev);
		return *this;
	}
	self operator--(int) {
		self tmp = *this;
		--*this;
		return tmp;
	}
};

数据结构

SGI list是一个环状双向链表，只需一个指针，便可完整表现这个链表。

template<class T,class Alloc=alloc>
class list {
protected:
	typedef __list_node<T> list_node;
public:
	typedef list_node* link_type;
protected:
	link_type node;
...
};

让指针node指向刻意置于尾端的一个空白节点，node就符合STL对于前闭后开区间的要求，成为last迭代器。

iterator begin() { return (link_type)((*node).next); }
iterator end() { return node; }
bool empty() const { return node->next == node; }
size_type size() const {
	size_type result = 0;
	distance(begin(), end(), result);
	return result;
}
//取头节点的内容
reference front() { return *begin(); }
//取尾节点的内容
reference back() { return *(--end()); }

构造和内存管理：construct，push_back，insert

list缺省使用alloc作为空间配置器，并据此另外定义了一个list_node_allocator，便于以节点大小为配置单元。

template<class T,class Alloc=alloc>
class list {
	typedef __list_node<T> list_node;
	//专属空间配置器，每次配置一个节点大小
	typedef simple_alloc<list_node, Alloc> list_node_allocator;
...
};

list_node_allocator(n)表示配置n个节点空间，以下四个函数，分别原来配置、释放、构造和销毁一个点：

protected:
	//配置一个节点并返回
	link_type get_node() { return list_node_allocator::allocate(); }
	//释放一个节点
	void put_node(link_type p) { list_node_allocator::deallocate(p); }

	//产生（配置并构造）一个节点，带有元素值
	link_type create_node(const T& x) {
		link_type p = get_node();
		construct(&p->data, x);
		return p;
	}
	//销毁（析构并释放）一个节点
	void destroy_node(link_type p) {
		destroy(&p->data);
		put_node(p);
	}

list允许我们不知道任何参数做出一个空的list出来：

public:
	list() { empty_initialize(); }
protected:
	void empty_initialize() {
		node = get_node();
		node->next = node;//令其头尾都指向自己，不设元素值
		node->prev = node;
	}

使用push_back()将新元素插入list尾端时，内部调用insert()：

public:
	void push_back(const T& x) { insert(end(), x); }

insert()是一个重载函数，有多种形式，最简单的一种是配置并构造一个节点，然后在尾端进行适当的指针操作，将新节点插入进去：

iterator insert(iterator position, const T& x) {//在position所指位置插入一个节点，内容为x
		link_type tmp = create_node(x);//产生一个节点
		//调整双向指针，插入tmp
		tmp->next = position.node;
		tmp->prev = position.node->prev;
		(link_type(position.node->prev))->next = tmp;
		position.node->prev = tmp;
		return tmp;
	}

元素操作：

push_front,push_back,erase,pop_front,pop_back,clear,remove,unique,splice,merge,reverse,sort

在头部或尾部插入元素，操作几乎是一样的；在头部或尾部删除元素，操作也几乎是一样的。

	//插入一个节点作为头节点
	void push_front(const T& x) { insert(begin(), x); }
	//插入一个节点作为尾节点
	void push_back(const T& x) { insert(end(), x); }

	//移除迭代器position所指节点
	iterator erase(iterator position) {
		link_type next_node = link_type(position.node->next);
		link_type prev_node = link_type(position.node->prev);
		prev_node->next = next_node;
		next_node->prev = prev_node;
		destroy_node(position.node);
		return iterator(next_node);
	}

	//移除头节点
	void pop_front() { erase(begin()); }
	//移除尾节点
	void pop_back() {
		iterator tmp = end();
		erase(--tmp);
	}

	//清除所有节点（整个链表）
	template<class T,class Alloc>
	void list<T, Alloc>::clear()
	{
		link_type cur = (link_type)node->next;
		while (cur != node)//遍历每一个节点
		{
			link_type tmp = cur;
			cur = (link_type)cur->next;
			destroy_node(tmp);//销毁一个节点
		}
		//恢复node原始状态
		node->next = node;
		node->prev = node;
	}

	//将数值为value的所有元素移除
	template<class T,class Alloc>
	void list<T, Alloc>::remove(const T& value) {
		iterator first = begin();
		iterator last = end();
		while (first != last) {//遍历每一个点
			iterator next = first;
			++next;
			if (*first == value)
				erase(first);//找到就移除
			firsst = next;
		}
	}

	//移除数值相同的连续元素，只有连续而相同的元素，才会被移除剩一个
	template <class T,class Alloc>
	void list<T, Alloc>::unique() {
		iterator first = begin();
		iterator last = end();
		if (first == last)return;//空链表返回
		iterator next = first;
		while (++next != last) {//遍历每一个节点
			if (*first == *next)//如果在此区段有相同的元素
				erase(next);//移除之
			else
				first = next;//否则调整指针
			next = first;//修正区段范围
		}
	}

list内部提供一个迁移操作(transfer)：将某范围内的元素迁移到某个特定位置之前，实际为节点间的指针移动。

protected:
	//将[first,last)内的所有元素移动到position之前
		void transfer(iterator position, iterator first, iterator last) {
			if (position != last) {
				(*(link_type((*last.node).prev))).next = position.node;//last前的元素与position相接
				(*(link_type((*first.node).prev))).next = last.node;//last与first前的元素相接
				(*(link_type((*position.node).prev))).next = first.node;//position前的元素与first相接
				link_type tmp = link_type((*position.node).prev);
				(*position.node).prev = (*last.node).prev;//position与last前的元素相接
				(*last.node).prev = (*first.node).prev;//first前的元素与last相接
				(*first.node).prev = tmp;//first与原position前的元素相接
			}
		}

transfer并非公开接口，list公开提供的是所谓的结合操作（splice）

public:
	//将x接合于position所指位置之前，x必须不同于*this
	void splice(iterator position, list& x)
	{
		if (!x.empty())
			transfer(position, x.begin(), x.end());
	}

	//将i所指元素接合于position所指位置之前，position和i可指向同一个list
	void splice(iterator position, list&, iterator i) {
		iterator j = i;
		++j;
		if (position == i || position == j)return;
		transfer(position, i, j);
	}

	//将[first,last)内所有元素接合于position所指位置之前
	//position和[first,last)可指向同一个list,
	//但position不能位于[first,last)之内
	void splice(iterator position, list&, iterator first, iterator last) {
		if (first != last)
			transfer(position, first, last);
	}

	//merge()将x合并到*this身上，两个lists的内容都必须先经过递增排序
	template <class T, class Alloc>
	void list<T, Alloc>::merge(list<T, Alloc>& x) {
		iterator first1 = begin();
		iterator last1 = end();
		iterator first2 = x.begin();
		iterator last2 = x.end();

		//前提是两个lists都已经过递增排序
		while (first1 != last1&&first2 != last2)
			if (*first2 < *first1) {
				iterator next = first2;
				transfer(first1, first2, ++next);
				first2 = next;
			}
			else
				++first1;
		if (first2 != last2)
			transfer(last1, first2, last2);
	}

	//reverse()将*this的内容逆向重置
	template <class T, class Alloc>
	void list<T, Alloc>::reverse() {
		//如果是空链表或只有一个元素，就不进行任何操作
		//使用size()==0||size()==1来判断，也可以，但是比较慢
		if (node->next == node || link_type(node->next)->next == node)
			return;
		iterator first = begin();
		++first;
		while (first != end()) {
			iterator old = first;
			++first;
			transfer(begin(), old, first);
		}
	}

	//list不能使用STL算法sort(),必须使用自己的sort()成员函数
	//因为STL的sort()只接受RamdonAccessIterator
	//本函数使用快速排序
	template <class T,class Alloc>
	void list<T, Alloc>::sort() {
		//如果是空链表或只有一个元素，就不进行任何操作
		//使用size()==0||size()==1来判断，也可以，但是比较慢
		if (node->next == node || link_type(node->next)->next == node)
			return;

		//一些新的lists，作为中介数据存放区
		list<T, Alloc> carry;
		list<T, Alloc> counter[64];
		int fill = 0;
		while (!empty()){
			carry.splice(carry.begin(), *this, begin());
			int i = 0;
			while (i<fill&&!counter[i].empty())
			{
				counter[i].merge(carry);
				carry.swap(counter[i++]);
			}
			carry.swap(counter[i]);
			if (i == fill)++fill;
		}
		for (int i = 1; i < fill; ++i)
			counter[i].merge(counter[i - 1]);
		swap(counter[fill - 1]);
	}