目录
1. list的介绍及使用
1.1 list的介绍
1.2 list的使用注意事项
2.list接口介绍及模拟实现
2.1构造编辑
2.2容量
2.3修改
3.list迭代器
4.迭代器失效
5.模拟实现
6.vector和list的区别
1. list的介绍及使用
1.1 list的介绍
list的文档介绍
1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
2. list的底层是带头双向循环链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)
1.2 list的使用注意事项
1.list不支持随机访问，不能使用[ ]来访问元素。
2.list.sort()使用的是归并排序，默认为升序，如果需要排降序
// 降序
list<int> lt;
greater<int> it;
lt.sort(it);
//匿名对象
lt.sort(greater<int> ());但是使用list的sort排序效率不是很高，在处理数据量较多的情况下，可以将数据拷贝到vector中，再使用vector.sort()，再将数据拷贝回去。
list<int> lt;
vector<int> v(lt.begin(), lt.end());
sort(v.begin(), v.end());
lt.assign(v.begin(), v.end());2.list接口介绍及模拟实现
2.1构造
void empty_init()
{
head = new Node;
head->next = head;
head->prev = head;
_size = 0;
}
list()
{
empty_init();
}
list(const list& lt)
{
empty_init();
for (auto e : lt)
{
push_back(e);
}
}2.2容量
bool empty()
{
return head->next == head;
}
size_t size()
{
return _size;
}2.3修改
void push_front(const T& value)
{
insert(begin(), value);
}
void push_back(const T& value)
{
insert(end(), value);
}
void pop_front()
{
erase(begin());
}
void pop_back()
{
erase(--end());
}
void insert(iterator pos, const T& value = T())
{
Node* cur = pos._node;
Node* prev = cur->prev;
Node* newnode = new Node(value);
prev->next = newnode;
newnode->prev = prev;
newnode->next = cur;
cur->prev = newnode;
++_size;
}
iterator erase(iterator pos)
{
Node* cur = pos._node;
Node* prev = cur->prev;
Node* next = cur->next;
prev->next = next;
next->prev = prev;
delete cur;
--_size;
return next;
}
void swap(list<T>& lt)
{
std::swap(lt.head);
std::swap(lt.size)；
}
void clear()
{
iterator cur = begin();
while (cur != end())
{
cur = erase(cur);
}
}3.list迭代器
与vector和string不同，list的迭代器需要自己实现，list迭代器可以理解为一个指针，指向list中的某个结点，而链表的每个结点在物理空间上并不连续，所以当迭代器++的时候，并不能直接到下一个结点的位置，并且*的时候，并不知道访问的是链表中的哪个数据，所以我们需要自己实现，将迭代器进行封装。
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)
{}
Ref operator*()
{
return _node->date;
}
Ptr operator->()
{
return &_node->date;
}
self& operator++()
{
_node = _node->next;
return *this;
}
self& operator--()
{
_node = _node->prev;
return *this;
}
bool operator!=(const self& lt)
{
return _node != lt._node;
}
};需要注意的是，类模板参数有三个，是为了同时能实现迭代器和const迭代器，在list类中直接传不同的参数即可。
4.迭代器失效
此处大家可将迭代器暂时理解成类似于指针，迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。
void TestListIterator1()
{
int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
list<int> l(array, array+sizeof(array)/sizeof(array[0]));
auto it = l.begin();
while (it != l.end())
{
// erase()函数执行后，it所指向的节点已被删除，因此it无效，在下一次使用it时，必须先给其赋值
l.erase(it);
++it;
}
}
//修改
void TestListIterator()
{
int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
list<int> l(array, array+sizeof(array)/sizeof(array[0]));
auto it = l.begin();
while (it != l.end())
{
it = l.erase(it);
}
}5.模拟实现
namespace cola
{
template<class T>
struct _list_node
{
T date;
_list_node<T>* next;
_list_node<T>* prev;
_list_node(const T& value = T())
: date(value)
, 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)
{}
Ref operator*()
{
return _node->date;
}
Ptr operator->()
{
return &_node->date;
}
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& lt)
{
return _node != lt._node;
}
bool operator==(const self& lt)
{
return _node == lt._node;
}
};
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 head->next;
}
iterator end()
{
return head;
}
const_iterator begin() const
{
return head->next;
}
const_iterator end() const
{
return head;
}
void empty_init()
{
head = new Node;
head->next = head;
head->prev = head;
_size = 0;
}
list()
{
empty_init();
}
~list()
{
clear();
delete head;
}
list(const list& lt)
{
empty_init();
for (auto e : lt)
{
push_back(e);
}
}
list& operator=(const list& lt)
{
if (head != lt.head)
{
clear();
for (auto e : lt)
{
push_back(e);
}
}
return *this;
}
void push_front(const T& value)
{
insert(begin(), value);
}
void push_back(const T& value)
{
insert(end(), value);
}
void pop_front()
{
erase(begin());
}
void pop_back()
{
erase(--end());
}
void insert(iterator pos, const T& value = T())
{
Node* cur = pos._node;
Node* prev = cur->prev;
Node* newnode = new Node(value);
prev->next = newnode;
newnode->prev = prev;
newnode->next = cur;
cur->prev = newnode;
++_size;
}
iterator erase(iterator pos)
{
Node* cur = pos._node;
Node* prev = cur->prev;
Node* next = cur->next;
prev->next = next;
next->prev = prev;
delete cur;
--_size;
return next;
}
void swap(list<T>& lt)
{
std::swap(lt.head);
std::swap(lt.size)；
}
void clear()
{
iterator cur = begin();
while (cur != end())
{
cur = erase(cur);
}
}
bool empty()
{
return head->next == head;
}
size_t size()
{
return _size;
}
private:
Node* head;
size_t _size;
};
//打印函数（适用于任何容器）
template<typename Container>
void print_container(const Container& lt)
{
typename Container::const_iterator it = lt.begin();
while (it != lt.end())
{
cout << *it << " ";
++it;
}
cout << endl;
}
}6.vector和list的区别
