list是个环形双向链表,里面的迭代器类型是bidirectional_iterator_tag,可以双向移动,不想vector里可以随机访问。同时删除或添加结点对其他的迭代器无影响。List也有sort函数,我们知道sort函数只支持随机访问型迭代器,所有它的sort是自己另外声明的。下面是源码分析,基本都标注了各函数功能和分析
template <class T>
struct __list_node //链表节点
{
typedef void* void_pointer;
void_pointer next;
void_pointer prev;
T data;
};
template<class T, class Ref, class Ptr> //使结点能进行->,*等操作
struct __list_iterator
{
//迭代器,用到了偏特化,当模板参数是T, T&, T* 对应iterator
typedef __list_iterator<T, T&, T*> iterator;
typedef __list_iterator<T, const T&, const T*> const_iterator;
typedef __list_iterator<T, Ref, Ptr> self;
//list的迭代器类型是bidirectional_iterator_tag
typedef bidirectional_iterator_tag iterator_category;
typedef T value_type;
typedef Ptr pointer;
typedef Ref reference;
typedef __list_node<T>* link_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
//指向结点的指针
link_type node;
//迭代器构造函数
__list_iterator(link_type x) : node(x) {}
__list_iterator() {}
__list_iterator(const iterator& x) : node(x.node) {}
//运算符重载
bool operator==(const self& x) const { return node == x.node; }
bool operator!=(const self& x) const { return node != x.node; }
// 对迭代器取值,取的是节点的数据值
reference operator*() const { return (*node).data; }
// 指向迭代器就是指向其数据
pointer operator->() const { return &(operator*()); }
// 迭代器后移
self& operator++()
{
node = (link_type)((*node).next);
return *this;
}
self operator++(int)
{
self tmp = *this;
++*this;
return tmp;
}
// 前移
self& operator--()
{
node = (link_type)((*node).prev);
return *this;
}
self operator--(int)
{
self tmp = *this;
--*this;
return tmp;
}
};
template <class T, class Alloc = alloc>
class list
{
protected:
typedef void* void_pointer;
typedef __list_node<T> list_node;
//list空间配置函数
typedef simple_alloc<list_node, Alloc> list_node_allocator;
public:
typedef T value_type;
typedef value_type* pointer;
typedef value_type& reference;
typedef list_node* link_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef __list_iterator<T, T&, T*> iterator;
protected:
link_type node ;
//调用空间配置器分配一个结点
link_type get_node() { return list_node_allocator::allocate(); }
//释放一个结点
void put_node(link_type p) { list_node_allocator::deallocate(p); }
//构造结点
link_type create_node(const T& x)
{
link_type p = get_node();
construct(&p->data, x);
return p;
}
// 析构结点元素, 并释放内存
void destroy_node(link_type p)
{
destroy(&p->data);
put_node(p);
}
protected:
// 初始化时申请了一个空结点
void empty_initialize()
{
node = get_node();
node->next = node;
node->prev = node;
}
// 创建值为value共n个结点的链表
void fill_initialize(size_type n, const T& value)
{
empty_initialize();
__STL_TRY
{
//在头结点后插入n个值为value的结点
insert(begin(), n, value);
}
__STL_UNWIND(clear(); put_node(node));
}
public:
list() { empty_initialize(); }
//从头结点的下一个开始
iterator begin() { return (link_type)((*node).next); }
//返回头结点(环形链表)
iterator end() { return node; }
// 头结点指向自身说明链表中无元素
bool empty() const { return node->next == node; }
// 使用distance()进行计算, 时间复杂度O(n)
size_type size() const
{
size_type result = 0;
distance(begin(), end(), result); //对于b型迭代器计算距离只能一步步,开销较大
return result;
}
size_type max_size() const { return size_type(-1); }
reference front() { return *begin(); }
reference back() { return *(--end()); }
iterator insert(iterator position, const T& x)
{
//创建个结点
link_type tmp = create_node(x);
tmp->next = position.node;
tmp->prev = position.node->prev;
(link_type(position.node->prev))->next = tmp;
position.node->prev = tmp;
return tmp;
}
//连续插入几个结点
void insert(iterator pos, size_type n, const T& x);
void insert(iterator pos, int n, const T& x)
{
insert(pos, (size_type)n, x);
}
void insert(iterator pos, long n, const T& x)
{
insert(pos, (size_type)n, x);
}
// 在链表前端插入结点
void push_front(const T& x) { insert(begin(), x); }
// 在链表最后插入结点
void push_back(const T& x) { insert(end(), x); }
// 移除迭代器position所指节点,注意移除后其他结点迭代器任有效
iterator erase(iterator position)
{
link_type next_node = link_type(position.node->next);
link_type prev_node = link_type(position.node->prev);
prev_node->next = next_node;
next_node->prev = prev_node;
destroy_node(position.node);
return iterator(next_node);
}
iterator erase(iterator first, iterator last);
void resize(size_type new_size, const T& x);
void resize(size_type new_size) { resize(new_size, T()); }
void clear();
// 删除链表第一个结点
void pop_front() { erase(begin()); }
// 删除链表最后一个结点
void pop_back()
{
iterator tmp = end();
erase(--tmp);
}
list(size_type n, const T& value) { fill_initialize(n, value); }
list(int n, const T& value) { fill_initialize(n, value); }
list(long n, const T& value) { fill_initialize(n, value); }
~list()
{
// 释放所有结点 // 使用全局函数distance()进行计算, 时间复杂度O(n)
size_type size() const
{
size_type result = 0;
distance(begin(), end(), result);
return result;
}
clear();
// 释放头结点
put_node(node);
}
list<T, Alloc>& operator=(const list<T, Alloc>& x);
protected:
//将[first, last)范围内的元素移动到position前
void transfer(iterator position, iterator first, iterator last)
{
if (position != last)
{
//有点绕,画画图就清晰了
(*(link_type((*last.node).prev))).next = position.node;
(*(link_type((*first.node).prev))).next = last.node;
(*(link_type((*position.node).prev))).next = first.node;
link_type tmp = link_type((*position.node).prev);
(*position.node).prev = (*last.node).prev;
(*last.node).prev = (*first.node).prev;
(*first.node).prev = tmp;
}
}
public:
// 将链表x移动到position所指位置之前
void splice(iterator position, list& x)
{
if (!x.empty())
transfer(position, x.begin(), x.end());
}
// 将链表中i指向的内容移动到position之前
void splice(iterator position, list&, iterator i)
{
iterator j = i;
++j;
if (position == i || position == j) return;
transfer(position, i, j);
}
// 将链表[first, last}元素移动到position之前
void splice(iterator position, list&, iterator first, iterator last)
{
if (first != last)
transfer(position, first, last);
}
void remove(const T& value);
void unique();
void merge(list& x);
void reverse();
void sort();
};
// 销毁所有结点, 将链表置空
template <class T, class Alloc>
void list<T, Alloc>::clear()
{
link_type cur = (link_type) node->next;
while (cur != node)
{
link_type tmp = cur;
cur = (link_type) cur->next;
destroy_node(tmp);
}
node->next = node;
node->prev = node;
}
//链表直接赋值
template <class T, class Alloc>
list<T, Alloc>& list<T, Alloc>::operator=(const list<T, Alloc>& x)
{
if (this != &x)
{
iterator first1 = begin();
iterator last1 = end();
const_iterator first2 = x.begin();
const_iterator last2 = x.end();
while (first1 != last1 && first2 != last2) *first1++ = *first2++;
if (first2 == last2)
erase(first1, last1); //将原先多余的点去掉
else
insert(last1, first2, last2);
}
return *this;
}
//将相邻的重复的点去掉
template <class T, class Alloc>
void list<T, Alloc>::unique()
{
iterator first = begin();
iterator last = end();
if (first == last) return;
iterator next = first;
while (++next != last)
{
if (*first == *next)
erase(next);
else
first = next;
next = first;
}
}
template <class T, class Alloc>
void list<T, Alloc>::merge(list<T, Alloc>& x)
{
iterator first1 = begin();
iterator last1 = end();
iterator first2 = x.begin();
iterator last2 = x.end();
while (first1 != last1 && first2 != last2)
if (*first2 < *first1)
{
iterator next = first2;
transfer(first1, first2, ++next);
first2 = next;
}
else
++first1;
if (first2 != last2)
transfer(last1, first2, last2);
}
来简单实践下它的操作函数
#include <iostream>
#include <list>
#include <vector>
using namespace std;
void Print(list<int> s){
auto start = s.begin();
auto end = s.end();
while(start != end){
cout<<*start<<" ";
start++;
}
cout<<endl;
}
int main()
{
list<int> s(5,3);
Print(s);
s.insert(s.begin(),4); //注意不能写成s.begin()+n
Print(s);
vector<int> ss{1,2,3,4};
s.insert(s.begin(),ss.begin(),ss.end()); //可以在链表中加上任意容器元素
Print(s);
//s.transfer(s.begin(),ss.begin(),ss.end()); //?不能直接调用?
list<int> s1(5,7);
//insert是创建新的结点,splice是直接将原来的结点交接到这个链表后面
s.splice(s.end(),s1); //将链表拼接在迭代器后
Print(s);
s.reverse();
Print(s);
s.sort();
Print(s);
return 0;
}