从零开始写STL-容器-list

从零开始写STL-容器-list

• List 是STL 中的链表容器，今天我们将通过阅读和实现list源码来解决一下问题：
• List内部的内存结构是如何实现的？
• 为什么List的插入复杂度为O(1)？
• 为什么List的size()函数复杂度为O(n)?

list 容器的幕后英雄 - list 结点

作为一个链表首先要维护数据（模板元素的实例内容），指向前一个节点的指针 和 指向后一个节点的指针。List 的 结点作为list 容器中 元素内容 和 容器组织逻辑的一个中间层。

• 为什么不能搞成单向链表？
  
  如果单向链表的话，请您试想一下要删除迭代器pos指向的元素应该怎么操作？我们必须知道前驱后继才能正确进行删除

for(auto it = begin(); it != end(); it++)
{
	if(it->next == pos)
	{
		//...逻辑代码
	}
}

这样的单向链表每次寻找一个节点的前驱 后继 都要经过最坏复杂度为O(n)的查询，所有应该实现为双向链表。

list 容器的 迭代器

• 维护一个指向list_node 的指针

	template<class T>
	struct list_iterator : public bidirectional_iterator<T>
	{}//继承bidirectional_iterator类 便于类型萃取 和 特定算法应用

list 容器的 逻辑结构

• 环状链表
  
  node 表示尾部的一个空白结点，其next 指向list的头节点, pre指向list的尾节点

为什么这样设计？

首先list作为双向链表需要提供向前和向后的迭代能力，这样设计可以在O1的时间获得首尾元素，而且可以避免链表为空时的边界检查（只需要看一下node->pre == node，则为空）

		node_ptr get_node()
		{
			return data_allocator.allocate(1);
		}
		node_ptr new_node(const T& x)
		{
			node_ptr p = get_node();
			construct(&p->data, x);
			p->next = p->pre = nullptr;
			return p;
		}

构造函数

		list()
		{
			//注意 typedef  std::allocator<list_node<T>> Data_allocator;
			node.ptr = data_allocator.allocate(1);
			node.ptr->next = node.ptr->pre = node.ptr;
		}
		list(const self& rhs) :list(rhs.begin(), rhs.end())
		{

		}
		list(std::initializer_list<T> li):list(li.begin(),li.end())
		{

		}
		template<class c>
		list(const c l,const c r)
		{
			node.ptr = data_allocator.allocate(1);
			node.ptr->next = node.ptr->pre = node.ptr;
			for (auto it = l; it != r; it++)
			{
				push_back((*it));//逐个插入到list的末端
			}
		}
		list(size_type n, const T& val)
		{
			node.ptr = data_allocator.allocate(1);//初始化node
			node.ptr->next = node.ptr->pre = node.ptr;
			while (n--)
				push_back(val);
		}

析构函数

遍历列表 销毁数据实例

		~list()
		{
			if (!empty())
			{
				for (iterator it = begin(); it != end(); )
				{
					data_allocator.destroy(&it.ptr->data);
					it++;
				}
			}
		}

Modify

• 注意指针操作的先后顺序

		void push_front(const T& x)
		{
			node_ptr p = new_node(x);
			node.ptr->next->pre = p;
			p->next = node.ptr->next;
			node.ptr->next = p;
			p->pre = node.ptr;
		}
		void push_back(const T& x)
		{
			node_ptr p = new_node(x);
			node.ptr->pre->next = p;
			p->pre = node.ptr->pre;
			p->next = node.ptr;
			node.ptr->pre = p;
		}
		void pop_front()
		{
			node_ptr tmp = node.ptr->next;
			node.ptr->next = node.ptr->next->next;
			node.ptr->next->pre = node.ptr;
			data_allocator.deallocate(tmp,sizeof(list_node));
		}
		void pop_back()
		{
			node_ptr tmp = node.ptr->pre;
			node.ptr->pre = tmp->pre;
			tmp->pre->next = node.ptr;
			data_allocator.deallocate(tmp, sizeof(list_node));
		}
		iterator erase(iterator pos)
		{
			pos.ptr->pre->next = pos.ptr->next;
			pos.ptr->next->pre = pos.ptr->pre;// 前驱 后继 结点的指针操作
			node_ptr tmp = pos.ptr->next;
			destroy(&pos.ptr->data);//销毁
			data_allocator.deallocate(pos.ptr,sizeof(list_node));// 回收内存
			return iterator(tmp);
		}
		iterator erase(iterator first, iterator last)
		{
			first.ptr->pre->next = last.ptr;
			last.ptr->pre = first.ptr->pre;
			for (auto it = first; it != last; it++)
				destroy(&it.ptr->data);
			return first;
		}
		//The list container is extended by inserting new elements before the element at position.
		iterator insert(iterator pos, const T& x)
		{
			node_ptr p = new_node(x);
			pos.ptr->pre->next = p;
			p->pre = pos.ptr->pre;
			p->next = pos.ptr;
			pos.ptr->pre = p;
			return pos;
		}

		void insert(iterator pos, size_type sz, const T& x)
		{
			while (sz--)
				insert(pos, x);
		}

Splice 函数

		/* 将 first到last的元素移动到 pos 之前 */
		void transfer(iterator pos, iterator first, iterator last)
		{
			if (pos != last)
			{
				last.ptr->pre->next = pos.ptr;
				first.ptr->pre->next = last.ptr;
				pos.ptr->pre->next = first.ptr;
				auto tmp = pos.ptr->pre;
				pos.ptr->pre = last.ptr->pre;
				last.ptr->pre = first.ptr->pre;
				first.ptr->pre = tmp;
			}
		}
		void splice(iterator pos, list<T>& rhs)
		{
			if (*this != rhs)
				transfer(pos, rhs.begin(), rhs.end());
		}
		void splice(iterator pos, list<T>& rhs, iterator first, iterator last)
		{
			if (*this != rhs)
			{
				transfer(pos, first, last);
			}
		}
		void splice(iterator pos, list<T>& rhs, iterator it)
		{
			it.ptr->pre->next = it.ptr->next;
			it.ptr->next->pre = it.ptr->pre;
			pos.ptr->pre->next = it.ptr;
			it.ptr->pre = pos.ptr->pre;
			pos.ptr->pre = it.ptr;
			it.ptr->next = pos.ptr;
		}

merge 函数

注意链表的merge函数 和算法库中含义有所不同，在这里会将参数链表全部合并进来（也就是说在调用完这个函数之后，other 参数应该是空）

		void merge(list<T> &other)
		{
			auto p1 = begin(), p2 = other.begin();
			while (p1 != end() && p2 != other.end())
			{
				if (*p1 < *p2)
					p1++;
				else if (*p1 >= *p2)
				{
					auto tmp = p2;// 注意保存迭代器下一个位置，如果不保存，直接再调用splice之后p2++会怎样？首先p2!=other.end()这个条件永远不会触发，因为p2已经到了this的链表中
					tmp++;
					splice(p1, other, p2);
					p2 = tmp;
				}
			}
			if (!other.empty()) {
				splice(end(), other);
			}
		}

list 归并排序的非递归形式(难点)

非递归形式的 归并排序，因为List并不支持随机存取迭代器，sort不能用于排序list。

归并的思路如下：先建立64个桶，然后从前向后遍历，每次从要排序的list头取出一个元素插入桶中，第一个桶要存的元素最多为1个，第二个桶要存的最多为2个，第K个桶最多为2^K个元素。在插入元素的时候从前向后插入，如果到达当前桶的上限就向后归并。

具体的算法实现极为巧妙！

个人感觉参考了位运算的进位性质

		void sort()
		{
			if (size() <= 1)
			{
				return;
			}
			self carry;
			self 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]);
		}