1.简要介绍list
1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器,并且该容器可以前后双向迭代。(相较于vector,list的的插入删除效率更高,因为底层数据结构是链表,没有挪动数据和插入数据带来的巨大消耗)。
2. list的底层是双向链表结构,双向链表中每个元素存储在互不相关的独立节点中,在节点中通过指针指向其前一个元素和后一个元素。
3. list与forward_list非常相似:最主要的不同在于forward_list是单链表,只能朝前迭代,已让其更简单高效。
4. 与其他的序列式容器相比(array,vector,deque),list通常在任意位置进行插入、移除元素的执行效率更好。
5. 与其他序列式容器相比,list和forward_list最大的缺陷是不支持任意位置的随机访问,比如:要访问list的第6个元素,必须从已知的位置(比如头部或者尾部)迭代到该位置,在这段位置上迭代需要线性的时间开销;list还需要一些额外的空间,以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)。
2.list的使用
由于之前已经具体介绍过vector的用法,这里不再详细说明list的相关接口。
可以对照文档查阅:list文档
其中较为常用的有:
begin: 获取起始位置迭代器
end: 获取有效位置的下一个位置的迭代器
push_front: 头插数据
pop_front: 尾删数据
push_back: 尾插数据
pop_back: 尾删数据
erase: 指定位置删除数据,并且返回其有效位置的下一个位置的迭代器
insert: 指定位置前插入数据
swap:交换两个list容器的内容
list的使用总体来说比较简单,其中需要注意的点是:
1.list提供的迭代器类型为bidirectional_iterator(双向迭代器),而之前提到的vector提供的是random_access_iterator(随机迭代器),两者的区别是双向迭代器提供了++,--,!= ,==的运算符重载,但是不支持 +,-整数,以及> <等运算符。这也导致了双向迭代器不支持随机访问,无法使用sort等需要随机迭代器的函数。
2.执行删除操作后,删除位置的迭代器会失效,需要通过返回值更新
3.list的模拟实现
为了更加清晰的展示,以下都为声明和定义分离的形式。
3.1 list底层数据结构以及封装
为了实现链表的的数据结构,首先要定义list的节点:
//list节点类
template<class T>//设计成模板,实现基本的泛型结构
struct ListNode
{
ListNode(const T& val = T());//提供默认构造
ListNode<T>* _pPre;//指向上一个节点的指针
ListNode<T>* _pNext;//指向下一个节点的指针
T _val;//数据
};
template<class T>
ListNode<T>::ListNode(const T& val)//构造
:_pPre(this) //提供一个传入数据的构造
, _pNext(this) //方便list使用
, _val(val)
{}
链表数据结构的框架非常简单,重点在下面的增删查改操作中。
3.2 list的主体结构
//list类
template<class T>
class list
{
typedef ListNode<T> Node;
typedef Node* PNode;
typedef ListIterator<T, T&, T*> iterator; //重点关注iterator和const_iterator
//模板参数的区别
typedef ListIterator<T, const T&, const T*> const_iterator;
typedef Reverse_iterator<iterator,T&,T*> reverse_iterator;
typedef Reverse_iterator<const_iterator, const T&, const T*> const_reverse_iterator;
public:
list();//默认构造
list(int n ,const T& value = T());//n个元素构造
template<class Iterator>
list(Iterator first, Iterator last);//任意迭代器区间初始化
list(const list<T>& l);//拷贝构造
list<T>& operator=(const list<T>& l);//赋值运算符重载
~list();//析构
//list iterator
iterator begin();//获取起始位置迭代器
iterator end();//获取有效位置的下一个迭代器
const_iterator begin()const;//体现了iterator设置三个参数的好处
const_iterator end()const;// 不用单独写const迭代器的函数逻辑
//反向迭代器
reverse_iterator rbegin();//获取反向起始位置迭代器
reverse_iterator rend();//获取反向末尾位置迭代器
const_reverse_iterator rbegin()const;//反向const版
const_reverse_iterator rend()const;//反向const版
//list modify
void push_back(const T& val);//尾插
void pop_back();//尾删
void pop_front();//头删
void push_front(const T& val);//头插
iterator erase(iterator pos);//指定位置删除
iterator insert(iterator pos, const T& val);//在pos位置前插入
void clear();//清空list
void swap(list<T>& l);//交换
// list access
T& front();//获取起始元素
const T& front()const;//获取起始元素
T& back();//获取末尾元素
const T& back()const;//获取末尾元素
//list capacity
size_t size()const;//获取元素个数
bool empty();//判断是否为空
private:
PNode _pHead;//头节点指针
void CreateHead();//创建头节点(建议分离出来,因为各个构造都要用)
};
从list主体部分可以看出,比较复杂的部分在于Listiterator(链表迭代器)的相关定义和封装,这也是list实现的难点。
3.3 list的初始化以及销毁(构造析构等)具体实现
//list部分
template<class T>
list<T>::list()//默认构造
{
CreateHead();//复用CreateHead()
}
template<class T>
list<T>::list(int n, const T& value)//n个元素构造
{
CreateHead();//复用CreateHead()
for (int i = 0; i < n; ++i)
{
push_back(value);//复用push_back
}
}
template<class T>
template<class Iterator>
list<T>::list(Iterator first, Iterator last)//任意迭代器区间初始化
{
CreateHead();//复用CreateHead()
while (first != last)
{
push_back(*first);
++first;
}
}
template<class T>
list<T>::list(const list<T>& l)//拷贝构造
{
CreateHead();//复用CreateHead()
auto it = l.begin();
while (it != l.end())
{
push_back(*it);
++it;
}
}
template<class T>
list<T>& list<T>::operator=(const list<T>& l)//赋值运算符重载
{
//赋值前先清理被赋值对象的资源
clear();
//注意是深拷贝
for (auto e : l)
{
push_back(e);//复用push_back
}
return *this;
}
template<class T>
list<T>::~list()//析构
{
while (!empty())
{
erase(begin());//复用erase()逻辑,也可复用clear()
}
//由于erase()无法释放头节点,所以头节点要手动释放
delete _pHead;
_pHead = nullptr;
}
其中复用了CreateHead(),以及erase(),push_back等操作(在增删查改部分) ,CreateHead()的具体实现如下:
template<class T>
void list<T>::CreateHead()//创建头节点
{
_pHead = new Node;
}
list的底层数据结构是带头双向链表,所以在初始化过程中要先创建头节点。
3.4 list增删查改具体实现
template<class T>
typename list<T>::iterator list<T>::insert(iterator pos, const T& val)//在pos位置前插入
{
PNode newnode = new Node(val);
PNode pcur = pos._pNode;
PNode prev = pcur->_pPre;
newnode->_pNext = pcur;
newnode->_pPre = prev;
prev->_pNext = newnode;
pcur->_pPre = newnode;
return newnode;
}
template<class T>
void list<T>::push_front(const T& val)//头插
{
insert(begin(), val);
}
template<class T>
void list<T>::pop_front()//头删
{
erase(begin());
}
template<class T>
void list<T>::pop_back()//尾删
{
erase(--end());
}
template<class T>
void list<T>::push_back(const T& val)//尾插
{
insert(_pHead, val);
}
template<class T>
typename list<T>::iterator list<T>::erase(iterator pos)//指定位置删除
{
//判断pos位置是否为头节点
assert(pos != end());
//保存pos节点之前,之后的节点指针,便于删除后链接前后
PNode pcur = pos._pNode;//访问迭代器中的节点
PNode prev = pcur->_pPre;
PNode pnext = pcur->_pNext;
//释放pos位置节点
delete pcur;
prev->_pNext = pnext;
pnext->_pPre = prev;
return pnext;//注意返回值是pos节点的下一个
}
template<class T>
void list<T>::clear()//清空list
{
while (!empty())
{
erase(begin());
}
}
template<class T>
void list<T>::swap(list<T>& l)//交换
{
//直接交换头节点指针,减少消耗
PNode tmp = _pHead;
_pHead = l._pHead;
l._pHead = tmp;
}
template<class T>
T& list<T>::front()//获取起始元素
{
return *begin();
}
template<class T>
const T& list<T>::front()const//获取起始元素
{
return *begin();
}
template<class T>
T& list<T>::back()//获取末尾元素
{
return *(--end());
}
template<class T>
const T& list<T>::back()const//获取末尾元素
{
return *(--end());
}
template<class T>
size_t list<T>::size()const//获取元素个数
{
size_t count = 0;
for (auto e : *this)
{
++count;
}
return count;
}
template<class T>
bool list<T>::empty()//判断是否为空
{
return _pHead == _pHead->_pNext;
}
可以看到增删查改的核心在于insert(),和erase()函数,其他大多数只需要复用就可以了。
3.5 list迭代器的封装与实现
首先是迭代器的主体部分:
//list迭代器类
//这样写的好处是只用写一个模板就可以实现iterator和const_iterator
template<class T, class Ref, class Ptr>
struct ListIterator
{
typedef ListNode<T>* PNode;
typedef ListIterator<T, Ref, Ptr> Self;
ListIterator(PNode pNode = nullptr);//迭代器默认构造
Ref operator*();//解引用重载
Ptr operator->();//箭头重载
Self& operator--();// 前置--重载
Self operator--(int);// 后置--重载
Self& operator++();// 前置++重载
Self operator++(int);// 后置++重载
bool operator!=(const ListIterator<T, Ref, Ptr>& other);// !=重载
bool operator==(const Self& other);// ==重载
PNode _pNode;
};
需要注意的是模板参数列表中的三个值,在list主体中对应的传入类型,这样写提高了模板的泛用性,这样写的好处是只用写一个模板就可以实现iterator和const_iterator,需要仔细体会,这种代码复用叫做适配器模式。
具体实现:
template<class T>
typename list<T>::iterator list<T>::begin()//获取起始位置迭代器
{
return _pHead->_pNext;
}
template<class T>
typename list<T>::const_iterator list<T>::begin()const//获取起始位置迭代器
{
return _pHead->_pNext;
}
template<class T>
typename list<T>::iterator list<T>::end()//获取有效位置的下一个迭代器
{
return _pHead;
}
template<class T>
typename list<T>::const_iterator list<T>::end()const//获取有效位置的下一个迭代器
{
return _pHead;
}
//iterator内部分
template<class T, class Ref, class Ptr>
ListIterator<T, Ref, Ptr>::ListIterator(PNode pNode)//构造
:_pNode(pNode)
{}
template<class T,class Ref,class Ptr>
bool ListIterator<T, Ref, Ptr>::operator!=(const ListIterator<T, Ref, Ptr>::Self& other)// !=重载
{
return this->_pNode != other._pNode;
}
template<class T, class Ref, class Ptr>
bool ListIterator<T, Ref, Ptr>::operator==(const ListIterator<T, Ref, Ptr>::Self& other)// ==重载
{
return this->_pNode == other._pNode;
}
template<class T, class Ref, class Ptr>
Ptr ListIterator<T, Ref, Ptr>::operator->()// ->重载
{
return &_pNode->_val;
}
template<class T, class Ref, class Ptr>
Ref ListIterator<T, Ref, Ptr>::operator*()// *重载
{
return _pNode->_val;
}
template<class T, class Ref, class Ptr>
typename ListIterator<T, Ref, Ptr>::Self& ListIterator<T, Ref, Ptr>::operator--()// 前置--重载
{
_pNode = _pNode->_pPre;//内部指针向前走
return *this;
}
template<class T, class Ref, class Ptr>
typename ListIterator<T, Ref, Ptr>::Self ListIterator<T, Ref, Ptr>::operator--(int)// 后置--重载
{
PNode pcur = _pNode;//内部指针先保存再向前走
_pNode = _pNode->_pPre;
return pcur;
}
template<class T, class Ref, class Ptr>
typename ListIterator<T, Ref, Ptr>::Self& ListIterator<T, Ref, Ptr>::operator++()// 前置++重载
{
_pNode = _pNode->_pNext;//内部指针向后走
return *this;
}
template<class T, class Ref, class Ptr>
typename ListIterator<T, Ref, Ptr>::Self ListIterator<T, Ref, Ptr>::operator++(int)// 后置++重载
{
PNode pcur = _pNode;//内部指针先保存再向后走
_pNode = _pNode->_pNext;
return pcur;
}
在实现迭代器时核心思想就是封装底层结构,同时模拟指针的行为。
list与vector不同,因为空间不连续,想要模拟指针的行为必须封装后进行运算符重载,在进行++和--操作是实际上变更迭代器内部节点的地址。
3.6 list反向迭代器的封装和实现
//反向迭代器
template<class Iterator,class Ref,class Ptr>
struct Reverse_iterator
{
typedef Reverse_iterator<Iterator, Ref, Ptr> Self;
Reverse_iterator(Iterator it = Iterator());//反向迭代器默认构造
Ref operator*();//解引用重载
Ptr operator->();//箭头重载
Self& operator--();// 前置--重载
Self operator--(int);// 后置--重载
Self& operator++();// 前置++重载
Self operator++(int);// 后置++重载
bool operator!=(const Self& other);// !=重载
bool operator==(const Self& other);// ==重载
Iterator _it;//复用正向迭代器
};
类比上面普通迭代器的实现,反向迭代器同样可以使用适配器模式封装。
同时可以复用正向迭代器的代码,将逻辑反转即可:
template<class T>
typename list<T>::reverse_iterator list<T>::rbegin()//获取反向起始位置迭代器
{
return (--end());
}
template<class T>
typename list<T>::const_reverse_iterator list<T>::rbegin()const//获取反向起始位置迭代器const
{
return (--end());
}
template<class T>
typename list<T>::reverse_iterator list<T>::rend()//获取反向末尾位置迭代器
{
return (end());
}
template<class T>
typename list<T>::const_reverse_iterator list<T>::rend()const//获取反向末尾位置迭代器const
{
return (end());
}
//Reverse_iterator部分
template<class Iterator, class Ref, class Ptr>
Reverse_iterator<Iterator, Ref, Ptr>::Reverse_iterator(Iterator it)//反向迭代器默认构造
:_it(it)
{}
//全部复用iterator的(反着)
template<class Iterator, class Ref, class Ptr>
bool Reverse_iterator<Iterator, Ref, Ptr>::operator!=(const Reverse_iterator<Iterator, Ref, Ptr>::Self& other)// !=重载
{
return _it != other._it;
}
template<class Iterator, class Ref, class Ptr>
bool Reverse_iterator<Iterator, Ref, Ptr>::operator==(const Reverse_iterator<Iterator, Ref, Ptr>::Self& other)// ==重载
{
return _it == other._it;
}
template<class Iterator, class Ref, class Ptr>
Ptr Reverse_iterator<Iterator, Ref, Ptr>::operator->()// ->重载
{
return _it.operator->();
}
template<class Iterator, class Ref, class Ptr>
Ref Reverse_iterator<Iterator, Ref, Ptr>::operator*()// *重载
{
return *_it;
}
template<class Iterator, class Ref, class Ptr>
typename Reverse_iterator<Iterator, Ref, Ptr>::Self& Reverse_iterator<Iterator, Ref, Ptr>::operator--()// 前置--重载
{
++_it;
return *this;
}
template<class Iterator, class Ref, class Ptr>
typename Reverse_iterator<Iterator, Ref, Ptr>::Self Reverse_iterator<Iterator, Ref, Ptr>::operator--(int)// 后置--重载
{
Self temp = *this;
++_it;
return temp;
}
template<class Iterator, class Ref, class Ptr>
typename Reverse_iterator<Iterator, Ref, Ptr>::Self& Reverse_iterator<Iterator, Ref, Ptr>::operator++()// 前置++重载
{
--_it;
return *this;
}
template<class Iterator, class Ref, class Ptr>
typename Reverse_iterator<Iterator, Ref, Ptr>::Self Reverse_iterator<Iterator, Ref, Ptr>::operator++(int)// 后置++重载
{
Self temp = *this;
--_it;
return temp;
}
4.总结
list的封装比较复杂,如果是声明和定义分离的话,要注意指定类域到底是哪一个,要搞清list主体,list节点,list迭代器之间的关系,以及模板内部传参是如何向下传递的。最主要的难点就在于迭代器的实现,而且模板的使用过程中可能经常因为语法不正确而报一大堆错,需要细心检查。