list:每次插入或删除一个元素,就配置或释放一个元素空间。对于任意位置的元素插入或元素移除,list永远是常数时间。
节点(node)
template<class T>
struct __list_node
{
typedef void* void_pointer;
void_pointer prev;//型别为void*,其实也可以设置为__list_node<T>*
void_pointer next;
T data;
};
这是一个双向链表。
迭代器
STL list是一个双向链表,迭代器必须具有前移、后移的能力,所以list提供的是Bidirectional Iterator。
list有一个重要性质:插入操作(insert)和接合操作(splice)都不会造成原有的list迭代器失效,甚至删除操作(erase)也只有指向被删除元素的那个迭代器失效。
template<class T,class Ref,class Ptr>
struct __list_iterator
{
typedef __list_iterator<T, T&, T*> iterator;
typedef __list_iterator<T, Ref, Ptr> self;
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;
}
};
数据结构
SGI list是一个环状双向链表,只需一个指针,便可完整表现这个链表。
template<class T,class Alloc=alloc>
class list {
protected:
typedef __list_node<T> list_node;
public:
typedef list_node* link_type;
protected:
link_type node;
...
};
让指针node指向刻意置于尾端的一个空白节点,node就符合STL对于前闭后开区间的要求,成为last迭代器。
iterator begin() { return (link_type)((*node).next); }
iterator end() { return node; }
bool empty() const { return node->next == node; }
size_type size() const {
size_type result = 0;
distance(begin(), end(), result);
return result;
}
//取头节点的内容
reference front() { return *begin(); }
//取尾节点的内容
reference back() { return *(--end()); }
构造和内存管理:construct,push_back,insert
list缺省使用alloc作为空间配置器,并据此另外定义了一个list_node_allocator,便于以节点大小为配置单元。
template<class T,class Alloc=alloc>
class list {
typedef __list_node<T> list_node;
//专属空间配置器,每次配置一个节点大小
typedef simple_alloc<list_node, Alloc> list_node_allocator;
...
};
list_node_allocator(n)表示配置n个节点空间,以下四个函数,分别原来配置、释放、构造和销毁一个点:
protected:
//配置一个节点并返回
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);
}
list允许我们不知道任何参数做出一个空的list出来:
public:
list() { empty_initialize(); }
protected:
void empty_initialize() {
node = get_node();
node->next = node;//令其头尾都指向自己,不设元素值
node->prev = node;
}
使用push_back()将新元素插入list尾端时,内部调用insert():
public:
void push_back(const T& x) { insert(end(), x); }
insert()是一个重载函数,有多种形式,最简单的一种是配置并构造一个节点,然后在尾端进行适当的指针操作,将新节点插入进去:
iterator insert(iterator position, const T& x) {//在position所指位置插入一个节点,内容为x
link_type tmp = create_node(x);//产生一个节点
//调整双向指针,插入tmp
tmp->next = position.node;
tmp->prev = position.node->prev;
(link_type(position.node->prev))->next = tmp;
position.node->prev = tmp;
return tmp;
}
元素操作:
push_front,push_back,erase,pop_front,pop_back,clear,remove,unique,splice,merge,reverse,sort
在头部或尾部插入元素,操作几乎是一样的;在头部或尾部删除元素,操作也几乎是一样的。
//插入一个节点作为头节点
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);
}
//移除头节点
void pop_front() { erase(begin()); }
//移除尾节点
void pop_back() {
iterator tmp = end();
erase(--tmp);
}
//清除所有节点(整个链表)
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原始状态
node->next = node;
node->prev = node;
}
//将数值为value的所有元素移除
template<class T,class Alloc>
void list<T, Alloc>::remove(const T& value) {
iterator first = begin();
iterator last = end();
while (first != last) {//遍历每一个点
iterator next = first;
++next;
if (*first == value)
erase(first);//找到就移除
firsst = next;
}
}
//移除数值相同的连续元素,只有连续而相同的元素,才会被移除剩一个
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;//修正区段范围
}
}
list内部提供一个迁移操作(transfer):将某范围内的元素迁移到某个特定位置之前,实际为节点间的指针移动。
protected:
//将[first,last)内的所有元素移动到position之前
void transfer(iterator position, iterator first, iterator last) {
if (position != last) {
(*(link_type((*last.node).prev))).next = position.node;//last前的元素与position相接
(*(link_type((*first.node).prev))).next = last.node;//last与first前的元素相接
(*(link_type((*position.node).prev))).next = first.node;//position前的元素与first相接
link_type tmp = link_type((*position.node).prev);
(*position.node).prev = (*last.node).prev;//position与last前的元素相接
(*last.node).prev = (*first.node).prev;//first前的元素与last相接
(*first.node).prev = tmp;//first与原position前的元素相接
}
}
transfer并非公开接口,list公开提供的是所谓的结合操作(splice)
public:
//将x接合于position所指位置之前,x必须不同于*this
void splice(iterator position, list& x)
{
if (!x.empty())
transfer(position, x.begin(), x.end());
}
//将i所指元素接合于position所指位置之前,position和i可指向同一个list
void splice(iterator position, list&, iterator i) {
iterator j = i;
++j;
if (position == i || position == j)return;
transfer(position, i, j);
}
//将[first,last)内所有元素接合于position所指位置之前
//position和[first,last)可指向同一个list,
//但position不能位于[first,last)之内
void splice(iterator position, list&, iterator first, iterator last) {
if (first != last)
transfer(position, first, last);
}
//merge()将x合并到*this身上,两个lists的内容都必须先经过递增排序
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();
//前提是两个lists都已经过递增排序
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);
}
//reverse()将*this的内容逆向重置
template <class T, class Alloc>
void list<T, Alloc>::reverse() {
//如果是空链表或只有一个元素,就不进行任何操作
//使用size()==0||size()==1来判断,也可以,但是比较慢
if (node->next == node || link_type(node->next)->next == node)
return;
iterator first = begin();
++first;
while (first != end()) {
iterator old = first;
++first;
transfer(begin(), old, first);
}
}
//list不能使用STL算法sort(),必须使用自己的sort()成员函数
//因为STL的sort()只接受RamdonAccessIterator
//本函数使用快速排序
template <class T,class Alloc>
void list<T, Alloc>::sort() {
//如果是空链表或只有一个元素,就不进行任何操作
//使用size()==0||size()==1来判断,也可以,但是比较慢
if (node->next == node || link_type(node->next)->next == node)
return;
//一些新的lists,作为中介数据存放区
list<T, Alloc> carry;
list<T, Alloc> counter[64];
int fill = 0;
while (!empty()){
carry.splice(carry.begin(), *this, begin());
int i = 0;
while (i<fill&&!counter[i].empty())
{
counter[i].merge(carry);
carry.swap(counter[i++]);
}
carry.swap(counter[i]);
if (i == fill)++fill;
}
for (int i = 1; i < fill; ++i)
counter[i].merge(counter[i - 1]);
swap(counter[fill - 1]);
}