list详解及模拟底层实现
一,list的介绍与使用
- list是可以在常数范围内在任意位置进行插入和删除的序列式容器,并且该容器可以前后双向迭代。
- list的底层是双向链表结构,双向链表中每个元素存储在互不相关的独立节点中,在节点中通过指针指向 其前一个元素和后一个元素。
- list与forward_list非常相似:最主要的不同在于forward_list是单链表,只能朝前迭代,已让其更简单高效。
- 与其他的序列式容器相比(array,vector,deque),list通常在任意位置进行插入、移除元素的执行效率 更好
- 与其他序列式容器相比,list和forward_list最大的缺陷是不支持任意位置的随机访问,比如:要访问list的第6个元素,必须从已知的位置(比如头部或者尾部)迭代到该位置,在这段位置上迭代需要线性的时间开销
构造函数 | 接口说明 |
---|---|
list() | 构造空的list |
list (size_type n, const value_type& val = value_type()) | 构造的list中包含n个值为val的元素 |
list(const list& x) | 拷贝构造函数 |
list (InputIterator first, InputIterator last) | 用[first, last)区间中的元素构造list |
**此处一定要注意,是左闭右开的区间!!! **
list iterator的使用
函数声明 | 接口说明 |
---|---|
begin() end() | 正向迭代器,对迭代器执行++操作,迭代器向后移动 |
rbegin() rend() | 反向迭代器,对迭代器执行++操作,迭代器向前移动 |
其他重要接口
函数声明 | 接口说明 |
---|---|
empty | 判空 |
size | 返回list中有效节点个数 |
front | 返回list中第一个节点的值 |
back | 返回list中最后一个节点的值 |
push_front | 头插 |
pop_front | 头删 |
pop_front | 尾删 |
push_back | 尾插 |
insert | 在pos位置插入元素 |
erase | 删除pos位置的元素 |
swap | 交换两个list中的元素 |
clear | 清空list的元素 |
list的迭代器失效
迭代器失效即迭代器所指向的节点的无效,即该节点被删除了。因为list的底层结构为带头结点的双向循环链表,因此在list中进行插入时是不会导致list的迭代器失效的,只有在删除时才会失效,并且失效的只是指向被删除节点的迭代器,其他迭代器不会受到影响
二,list的模拟实现
我首先写了一个简单的日期类,方便后续测试
struct date
{
public:
date(int y=1900,int m=1,int d=1)
:_y(y)
,_m(m)
,_d(d)
{}
int _y;
int _m;
int _d;
};
在这里定义链表中的每一个节点,用模板可以支持更多类型包括自定义的类型。
首先一个节点是由一个数据,一个头指针,一个尾指针组成。
在构造函数中对三个变量进行初始化,注意val是const类型,是不可以修改的
template<class T>
struct ListNode
{
ListNode(const T& val=T())
{
_data = val;
_prev = nullptr;
_next = nullptr;
}
T _data;
ListNode<T>* _prev;
ListNode<T>* _next;
};
对于迭代器的实现
迭代器有两种实现方式,具体应根据容器底层数据结构实现:
- 原生态指针,比如:vector
- 将原生态指针进行封装,因迭代器使用形式与指针完全相同,因此在自定义的类中必须实现以下 方法:
1.指针可以解引用,迭代器的类中必须重载operator*()
2.指针可以通过->访问其所指空间成员,迭代器类中必须重载oprator->()
3.指针可以++向后移动,迭代器类中必须重载operator++()与operator++(int) 至于operator–()/operator–(int)释放需要重载,根据具体的结构来抉择,双向链表可 以向前移动,所以需要重载,如果是forward_list就不需要重载
4.迭代器需要进行是否相等的比较,因此还需要重载operator==()与operator!=()
我这里写了两个迭代器的构造函数,默认构造(用一个节点构造),还可以实现用一个迭代器构造另一个。
1.解引用() 的重载是返回节点的数据,返回类型为T&
2.前置++,前置-- 都是返回迭代器类型 Listiterator< T>& ,当然也是返回引用
3.后置++,后置-- 返回迭代器类型 Listiterator< T>
4.!=和==的重载 只需要判断这两个节点的地址是不是同一地址
5.->的重载 返回值类型为T,指针类型,返回节点中数据的地址,可以访问到其空间中的成员
例:it.operator->() ->_y ;先拿到数据的地址,在调用->, 访问其成员
template<class T,class ref,class ptr>
struct Listiterator
{
typedef ListNode<T> Node;
typedef Listiterator<T,ref,ptr> Self;
//封装一个节点
Node* _node;
Listiterator(Node* node)
:_node(node)
{}
Listiterator(const Self& lit) //用一个迭代器构造另一个
:_node(lit._node)
{}
ref operator*()
{
//cout << this->_node->_data;
return _node->_data;
}
Self& operator++() //返回迭代器 前置++
{
_node = _node->_next;
return *this;
}
Self& operator--() //返回迭代器 前置--
{
_node = _node->_prev;
return *this;
}
Self operator++(int) //后置++ 因为后置++返回原来的迭代器
{
Listiterator<T> tmp(*this);//拷贝构造一个迭代器
_node = _node->_next;
return tmp;
}
bool operator!=(const Self& it) const
{
return _node != it._node;
}
bool operator ==(const Self& it) const
{
return _node == it._node;
}
ptr operator ->()
{
return &this->_node->_data;
}
};
list类实现,包含一个成员:头节点 Node* _header;
无参构造:开辟一个头节点,前驱后驱都指向头节点本身
用n个val构造 :此处复用尾插函数
用一个迭代器构造:此处也是复用尾插函数,插入解引用的值
拷贝构造:复用迭代器构造创建出一个临时变量,也是一种深拷贝,与this进行交换(交换头指针),此时临时变量的内容为this的内容,函数生命周期结束临时变量释放。
赋值运算符重载:List< T>& operator=(List< T> ls)
传参时调用拷贝构造,构造出一个临时对象,再进行交换,同上
template<class T>
class List
{
public:
typedef ListNode<T> Node;
typedef Listiterator<T, T&, T*> iterator;
typedef Listiterator<T,const T&,const T*> const_iterator;
List()
{
_header = new Node;
_header->_prev = _header->_next = _header;
}
List(size_t n, const T& val = T())
{
_header = new Node;
_header->_prev = _header->_next = _header;
while (n--)
{
push_back(val);
}
}
List(const_iterator first, const_iterator last)
{
_header = new Node;
_header->_prev = _header->_next = _header;
while (first != last)
{
push_back(*first);
++first;
}
}
List(const List<T>& ls) //拷贝构造
{
_header = new Node;
_header->_prev = _header->_next = _header;
List<T> tmp(ls.begin(), ls.end()); //创建临时变量
this->Swap(tmp);
}
List<T>& operator=(List<T> ls)
{
//ls.push_back(T());
this->Swap(ls);
return *this;
}
void Swap(List<T>& ls) //交换两个对象的头
{
swap(this->_header, ls._header);
}
1.插入函数insert():位置pos与返回值都为迭代器类型,需要开辟新的节点,再对指针重新进行连接
2.删除函数erase():删除pos位置节点,并且会释放空间,返回的是下一个节点的位置
3.begin,end,const_begin,const_end : 调用迭代器类的构造函数,都是返回迭代器类型
4.clear()清空函数:通过迭代器,调用删除函数,清空链表
iterator it = begin();
while (it != end())
{
it=erase(it);
}
5.析构函数:调用clear(),然后释放头节点空间并置为nullptr
void clear()
{
iterator it = begin();
while (it != end())
{
it=erase(it);
}
}
void push_back(const T& val)
{
insert(--begin(), val);
}
iterator insert(iterator pos,const T& val=T())
{
Node* prev = pos._node->_prev;
Node* cur = new Node(val);
cur->_next = pos._node;
pos._node->_prev = cur;
prev->_next = cur;
cur->_prev = prev;
return iterator(cur);
}
iterator erase(iterator pos) //返回下一个节点的位置
{
Node* next = pos._node->_next;
pos._node->_prev->_next = next;
next->_prev = pos._node->_prev;
delete pos._node;
return iterator(next);
}
iterator begin()
{
return iterator(_header->_next);
}
iterator end()
{
return iterator(_header);
}
const_iterator begin() const
{
return const_iterator(_header->_next);
}
const_iterator end() const
{
return const_iterator(_header);
}
~List()
{
clear();
delete _header;
_header = nullptr;
}
三,测试
给出了一些测试用例,供读者参考
void test2()
{
cout << "创建一个date类型的对象:" << endl;
List<date> ls(3);
List<date>::iterator it = ls.begin();
while (it != ls.end())
{
cout << it->_y << " " << it->_m << " " << it->_d;
++it;
cout << endl;
}
cout << "date类型: 拷贝构造: " << endl;
List<date> ls2(ls);
List<date>::iterator it2 = ls2.begin();
while (it2 != ls2.end())
{
cout << it2->_y << " " << it2->_m << " " << it2->_d;
++it2;
cout << endl;
}
cout << "date类型 :带参构造:" << endl;
date d1(2, 2, 2);
List<date> ls3(3,d1);
it2 = ls3.begin();
while (it2 != ls3.end())
{
cout << it2->_y << " " << it2->_m << " " << it2->_d;
++it2;
cout << endl;
}
cout << "date类型: 赋值运算符重载:" << endl;
ls3 = ls2;
it2 = ls3.begin();
while (it2 != ls3.end())
{
cout << it2->_y << " " << it2->_m << " " << it2->_d;
++it2;
cout << endl;
}
cout << "调用插入 :" << endl;
date d2(2020, 6, 18);
ls3.insert(ls3.begin(),d2);
ls3.insert(ls3.begin(),d1);
ls3.insert(ls3.begin(),d1);
ls3.erase(ls3.begin());
it2 = ls3.begin();
while (it2 != ls3.end())
{
cout << it2->_y << " " << it2->_m << " " << it2->_d;
++it2;
cout << endl;
}
ls3.clear();
cout << "调用清空:" << endl;
it2 = ls3.begin();
while (it2 != ls3.end())
{
cout << it2->_y << " " << it2->_m << " " << it2->_d;
++it2;
cout << endl;
}
}
运行结果如下