1.list的介绍
- list的优点:
- list头部、中间插入不再需要挪动数据,O(1)效率高
- list插入数据是新增节点,不需要增容
- list的缺点:
- 不支持随机访问,访问某个元素效率O(N)
- 底层节点动态开辟,小节点容易造成内存碎片,空间利用率低,缓存利用率低。
1.1list的构造
- 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]的元素的容器,每个元素由该范围内其对应元素以相同顺序构造。
1.2list的iterator使用
- iterator begin()+iterator end()
- begin()函数返回一个迭代器,指向list的第一个元素
- end()函数返回一个迭代器,指向链表的末尾 - reverse_iterator rbegin()+reverse_iterator rend()
- rbegin()函数返回一个逆向迭代器,指向链表的末尾
- rend()函数迭代器指向链表的头部
1.3list的增删查改
- void push_front(const value_type& val)
将val连接到链表的头部 - void pop_front()
删除链表的第一个元素 - void push_back (const value_type& val)
将val连接到链表的最后 - void pop_back()
删除链表的最后一个元素 - iterator insert (iterator position, const value_type& val)
插入元素val到位置pos,返回一个迭代器指向被插入的元素 - iterator erase(iterater pos)
除以pos指示位置的元素,返回一个迭代器,指向被删除元素的下一个元素 - void swap(list& x)
交换链表x和现链表中的元素 - void clear()
删除list的所有元素
2.list的模拟实现
#pragma once
#include <iostream>
#include <algorithm>
#include <assert.h>
namespace mylist
{
template<class T>
struct __list_node
{
T _data;
__list_node<T>* _next;
__list_node<T>* _prev;
__list_node(const T& x = T())
:_data(x)
,_next(nullptr)
,_prev(nullptr)
{}
};
template<class T, class Ref, class Ptr>
struct __list_iterator
{
typedef __list_node<T> node;
typedef __list_iterator<T, Ref, Ptr> self;
node* _node;
__list_iterator(node* node)
:_node(node)
{}
bool operator!=(const self& s) const
{
return _node != s._node;
}
bool operator==(const self& s) const
{
return !(*this != s);
}
Ptr operator->() const
{
return &_node->_data;
}
Ref operator*() const
{
return _node->_data;
}
self operator++(int)
{
self tmp(*this);
_node = _node->_next;
return tmp;
}
self& operator++()
{
_node = _node->_next;
return *this;
}
self operator--(int)
{
self tmp(*this);
_node = _node->_prev;
return tmp;
}
self& operator--()
{
_node = _node->_prev;
return *this;
}
};
template<class T>
class list
{
typedef __list_node<T> node;
public:
typedef __list_iterator<T, T&, T*> iterator;
typedef __list_iterator<T, const T&, const T*> const_iterator;
iterator begin()
{
return iterator(_head->_next);
}
iterator end()
{
return _head;
}
const_iterator begin() const
{
return _head->_next;
}
const_iterator end() const
{
return _head;
}
list()
{
_head = new node;
_head->_next = _head;
_head->_prev = _head;
}
template<class InputIterator>
list(InputIterator first, InputIterator last)
{
_head = new node;
_head->_next = _head;
_head->_prev = _head;
while (first != last)
{
push_back(*first);
++first;
}
}
list(const list<T>& lt)
{
_head = new node;
_head->_next = _head;
_head->_prev = _head;
list<T> tmp(lt.begin(), lt.end());
std::swap(_head, tmp._head);
}
list<T>& operator=(list<T> lt)
{
std::swap(_head, lt._head);
return *this;
}
void push_back(const T& x)
{
node* newnode = new node(x);
node* tail = _head->_prev;
tail->_next = newnode;
newnode->_prev = tail;
_head->_prev = newnode;
newnode->_next = _head;
}
void push_front(const T& x)
{
insert(begin(), x);
}
void pop_back()
{
erase(--end());
}
void pop_front()
{
erase(begin());
}
iterator insert(iterator pos, const T& x)
{
node* newnode = new node(x);
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 = cur;
cur->_prev = prev;
delete cur;
return iterator(next);
}
void clear()
{
iterator it = begin();
while (it != end())
{
erase(it++);
}
}
~list()
{
clear();
delete _head;
_head = nullptr;
}
private:
node* _head;
};
}