list概述
环状双向链表
特点：
底层是使用链表实现的，支持双向顺序访问，不支持随机访问，因此访问某个元素需要遍历
在list中任何位置进行插入删除都很快，不会像vector那样子需要逐个移动其他元素
每个节点需要额外的内存
list节点
list的每一个节点都是一个结构体：
template <class T>
struct __list_node {
typedef void* void_pointer;
void_pointer prev; //类型为void*。其实可设为__list_node<T>*
void_pointer next;
T data;
};
list迭代器
由于list的内存是分散的，非连续的，因此不能再使用指针作为迭代器，需要设计链表的迭代器。
递增就是指向下一个节点，递减就是指向前一个节点，解引用就是取当前节点的data。
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的节点
// constructor
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; }
// 以下对迭代器取值（dereference），取的是节点的数据值
reference operator*() const { return (*node).data; }
// 以下是迭代器的成员存取（member access）运算子的标准作法
pointer operator->() const { return &(operator*()); }
//对迭代器累加1，就是前进一个节点
self& operator++()
node = (link_type)((*node).next);
return *this;
}
self operator++(int)
self tmp = *this;
++*this;
return tmp;
}
//对迭代器递减1，就是后退一个节点
self& operator--()
node = (link_type)((*node).prev);
return *this;
}
self operator--(int)
self tmp = *this;
--*this;
return tmp;
}
};
list的数据结构
list本身是一个环状的双向链表，所以它仅需一个指针就可以遍历整个链表。
我们选取一个空白节点作为尾端end()，这样子也满足stl的左闭右开的设计原则，我们再用一个指针node一直指向这个尾部。
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); // 全局函式，第 3章。
return result;
}
// 取头节点的内容（元素值）
reference front() { return *begin(); }
// 取尾节点的内容（元素值）
reference back() { return *(--end()); }
list构造与内存管理
list缺省使用的是alloc作为空间配置器，并据此另外定义了一个list的专属的空间配置器，以节点大小为单位分配空间。list_node_allocator(n) 表示配置n个节点空间
template <class T, class Alloc = alloc> //默认使用alloc为配置器
class list {
protected:
typedef __list_node<T> list_node;
// 专属之空间配置器，每次配置一个节点大小：
typedef simple_alloc<list_node, Alloc> list_node_allocator;
...
};
以下四个函数，分别用来配置、释放、建构、摧毁一个节点。
protected:
// 配置一个节点并传回
link_type get_node() { return list_node_allocator::allocate(); }
// 释放一个节点
void put_node(link_typep){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，且其前后节点都是指向自己
insert()函数
//函数目的：在迭代器 position 所指位置插入一个节点，内容为x
iterator insert(iterator position, const T& x) {
link_type tmp = create_node(x);//产生一个节点（设妥内容为x）
//调整双向指针，使 tmp插入进去
tmp->next = position.node;
tmp->prev = position.node->prev;
(link_type(position.node->prev))->next = tmp;
position.node->prev = tmp;
return tmp;
}
基于insert函数可以实现push_back(),push_front()
void push_front(const T& x) {isnert(begin(),x);}
void push_back(const T& x) {inset(end(),x);}
erase(）函数
//移除迭代器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);
}
基于erase()函数可以实现pop_back(),pop_front()函数
//移除头节点
void pop_front() { erase(begin()); }
//移除尾节点
void pop_back()
iterator tmp = end();
erase(--tmp);
}
clear函数
// 清除所有节点（整个链表）
template <class T, class Alloc>
void list<T, Alloc>::clear()
{
link_type cur = (link_type) node->next; //begin()
while (cur != node) { //遍历每一个节点
link_type tmp = cur;
cur = (link_type) cur->next;
destroy_node(tmp); // 销毁（析构并释放）一个节点
}
//恢复node原始状态
node->next = node;
node->prev = node;
}
remove()函数
//将数值为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); //找到就移除
first = next;
}
}
unique()函数
//移除数值相同的连续元素。注意，只有“连续而相同的元素”，才会被移除剩一个
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; //修正区段范围
}
}
transfer()函数
list内部提供一个所谓的迁移动作（transfer）：将某连续范围的元素迁移到某个特定位置之前。技术上很简单，节点间的指针移动而已
这个动作为其他的复杂动作如splice, sort, merge等奠定良好的基础
下面是transfer的源码，transfer不是公开接口：
protected:
//将[first,last)内的所有元素搬移到position之前
void transfer(iterator position, iterator first, iterator last) {
if (position != last) {
(*(link_type((*last.node).prev))).next = position.node; // (1)
(*(link_type((*first.node).prev))).next = last.node; // (2)
(*(link_type((*position.node).prev))).next = first.node; // (3)
link_type tmp = link_type((*position.node).prev); // (4)
(*position.node).prev = (*last.node).prev; // (5)
(*last.node).prev = (*first.node).prev; // (6)
(*first.node).prev = tmp; // (7)
}
}
sort()函数
由于list不支持随机访问，所以不能用stl的排序算法，需要使用链表自己的sort
//list不能使用STL算法sort()，必须使用自己的sort() member function，
//因为STL算法 sort()只接受RamdonAccessIterator.
//本函数采用 quick sort
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]);
}
扫一扫
9718
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
