【STL】07.list的模拟实现

一、list 的模拟实现

1.1 整体框架

//节点
template<class T>
struct ListNode
{
	T _val;
	ListNode* _prev;
	ListNode* _next;
};
//list类
template<class T>
class list
{
	typedef ListNode<T> Node;
public:

private:
	Node* _node;
};

1.2 list 的默认成员函数

1.2.1 list 的构造函数

//构造函数
void empty_Init()
{
	_node = new Node();
	_node->_next = _node;
	_node->_prev = _node;
}
list()
{
	empty_Init();
}
list(const list& x)
{
	empty_Init();
	for (const auto& e : x)
		push_back(e);
}
list(initializer_list<T> il)
{
	empty_Init();
	for (const auto& e : il)
		push_back(e);
}

1.2.2 list 的赋值重载

//赋值重载
list& operator=(const list<T>& x)
{
	list temp(x);
	//std::swap(_node,temp._node);
	swap(temp);
	return *this;
}

1.2.3 list 的析构函数

//析构函数
~list()
{
	clear();
	delete _node;
	_node = nullptr;
}

1.3 list 的迭代器

在vector中我们使用T*作为迭代器，那么在list中我们能否使用Node*作为迭代器呢？
我们发现++，!=，解引用等操作与我们的预期不符，因此我们在这里可以封装一个迭代器类来进行操作

template<class T,class Ref,class Ptr>
struct ListIterator
{
	//迭代器类的成员
	typedef ListNode<T> Node;
	typedef ListIterator Self;
	Node* _node;
	
	ListIterator(Node* node):_node(node){}
	//前置++ --
	Self& operator++()
	{
		_node = _node->_next;
		return *this;
	}
	Self& operator--()
	{
		_node = _node->_prev;
		return *this;
	}
	//后置++ --
	Self operator++(int)
	{
		Self temp(*this);
		_node = _node->_next;
		return temp;
	}
	Self operator--(int)
	{
		Self temp(*this);
		_node = _node->_prev;
		return temp;
	}
	//函数重载
	bool operator!=(const Self& x)
	{
		return _node != x._node;
	}
	Ref operator*()
	{
		return _node->_val;
	}
	Ptr operator->()
	{
		return &_node->_val;
	}
};

对迭代器类进行封装之后，Node* 的操作就会满足我们的预期了，接下来我们就可以把这个类定义成迭代器了

//迭代器的定义
typedef ListIterator<T, T&, T*> iterator;
typedef ListIterator<T, const T&,const T*> const_iterator;

//begin()
iterator begin()
{
	return iterator(_node->_next);
}
const_iterator begin() const
{
	return const_iterator(_node->_next);
}
//end()
iterator end()
{
	return iterator(_node);
}
const_iterator end() const
{
	return const_iterator(_node);
}

1.4 list 的容量操作

bool empty()
{
	return _node->_next == _node;
}
size_t size()
{
	auto cur = begin();
	size_t count = 0;
	while (cur != end())
	{
		count++;
		++cur;
	}
	return count;
}

1.5 list 的元素访问

//取第一个元素
T& front()
{
	return *(begin());
}
const T& front() const
{
	return *(begin());
}
//取最后一个元素
T& back()
{
	return *(--end());
}
const T& back() const
{
	return *(--end());
}

1.6 list 的容器修改

//尾插
void push_back(const T& val)
{
	Node* newnode = new Node(val);
	Node* tail = _node->_prev;
	tail->_next = newnode;
	newnode->_prev = tail;
	newnode->_next = _node;
	_node->_prev = newnode;
}
//尾删
void pop_back()
{
	assert(size() == 0);

	Node* tail = _node->_prev;
	Node* prev = tail->_prev;
	prev->_next = _node;
	_node->_prev = prev;
	delete tail;
	tail = nullptr;
}
//头插
void push_front(const T& val)
{
	Node* newnode = new Node(val);
	Node* next = _node->_next;
	_node->_next = newnode;
	newnode->_prev = _node;
	newnode->_next = next;
	next->_prev = newnode;
}
//头删
void pop_front()
{
	assert(size() == 0);

	Node* next = _node->_next;
	_node->_next = next->_next;
	next->_prev = _node;
	delete[] next;
	next = nullptr;
}
//插入
iterator insert(iterator pos, const T& val)
{
	Node* newnode = new Node(val);

	Node* cur = pos._node;
	Node* prev = cur->_prev;
	prev->_next = newnode;
	newnode->_prev = prev;
	newnode->_next = cur;
	cur->_prev = newnode;
	return iterator(newnode);
}
//删除
iterator erase(iterator pos)
{
	assert(pos != end());

	Node* cur = pos._node;
	Node* prev = cur->_prev;
	Node* next = cur->_next;

	prev->_next = next;
	next->_prev = prev;
	delete cur;
	cur = nullptr;
	return iterator(next);
}
//清空
void clear()
{
	auto it = begin();
	while (it != end())
	{
		it=erase(it);
	}
}
//交换
void swap(list& x)
{
	std::swap(_node, x._node);
}

二、模拟实现反向迭代器

其实理解了上面的正向迭代器的设计我们自然而然就能写出反向迭代器

//反向迭代器
template<class T, class Ref, class Ptr>
struct ListReverseIterator
{
	//迭代器类的成员
	typedef ListNode<T> Node;
	typedef ListReverseIterator Self;
	Node* _node;

	ListReverseIterator(Node* node) :_node(node) {}
	//前置++ --
	Self& operator++()//反向迭代器相当于--
	{
		_node = _node->_prev;
		return *this;
	}
	Self& operator--()//相当于++
	{
		_node = _node->_next;
		return *this;
	}
	//后置++ --
	Self operator++(int)
	{
		Self temp(*this);
		_node = _node->_prev;
		return temp;
	}
	Self operator--(int)
	{
		Self temp(*this);
		_node = _node->_next;
		return temp;
	}
	//函数重载
	bool operator!=(const Self& x)
	{
		return _node != x._node;
	}
	Ref operator*()
	{
		return _node->_val;
	}
	Ptr operator->()
	{
		return &_node->_val;
	}
};

typedef ListReverseIterator<T, T&, T*>	reverse_iterator;
typedef ListReverseIterator<T, const T&,const T*>	const_reverse_iterator;
//rbegin()
reverse_iterator rbegin()
{
	return reverse_iterator(_node->_prev);
}
const_reverse_iterator rbegin()const
{
	return const_reverse_iterator(_node->_prev);
}
//rend()
reverse_iterator rend()
{
	return reverse_iterator(_node);
}
const_reverse_iterator rend()const
{
	return const_reverse_iterator(_node);
}

三、list 与 vector 的对比

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

比较内容	vector	list
底层结构	动态顺序表，一段连续空间	带头结点的双向循环链表
随机访问	支持随机访问，访问某个元素效率O(1)	不支持随机访问，访问某个元素效率O(N)
插入和删除	任意位置插入和删除效率低，需要搬移元素，时间复杂度为O(N)，插入时有可能需要增容，增容：开辟新空间，拷贝元素，释放旧空间，导致效率更低	任意位置插入和删除效率高，不需要搬移元素，时间复杂度为O(1)
空间利用率	底层为连续空间，不容易造成内存碎片，空间利用率高，缓存利用率高	底层节点动态开辟，小节点容易造成内存碎片，空间利用率低，缓存利用率低
迭代器	原生态指针	对原生态指针(节点指针)进行封装
迭代器失效	在插入元素时，要给所有的迭代器重新赋值，因为插入元素有可能会导致重新扩容，致使原来迭代器失效，删除时，当前迭代器需要重新赋值否则会失效	插入元素不会导致迭代器失效，删除元素时，只会导致当前迭代器失效，其他迭代器不受影响
使用场景	需要高效存储，支持随机访问，不关心插入删除效率	大量插入和删除操作，不关心随机访问