1：相比于 vector 的连续线性空间，STL 中的 list 的构造要复杂许多，为双向链表形式。vector 插入或删除元素需要移动多个元素，所花时间为 O(n)，然而在 list 中每次插入或删除一个元素，就配置或释放一个元素空间，不需要移动其它元素，所化时间为
O(1)；
2：list 的节点(node)
因为 list 为双向链表形式，所以 list 的节点中包含两个指针，一个指向其上游节点，另外一个指向其下游节点，代码如下：
template <class T>
struct __list_node {
__list_node* prev;
__list_node* next;
T data;
}3：list 的迭代器
1)：list 迭代器指向 list 中的节点，list 迭代器的递增是指向下一个节点，递减是指向上一个节点，取值时取的是节点的数据值，成员取用时取用的是节点的成员；由此可见 list 迭代器具有前移和后移功能，所以其是 Bidirectional Iterators；
2)：list 迭代器的一个重要性质是 list 的插入操作(insert)和接合操作(splice)都不会造成原有的 list 迭代器失效。这在 vector 中是不成立的，因为 vector 的插入操作可能造成内存空间重新分配，导致原有的迭代器全部失效；并且 list 的元素删除操作(erase) 也只有“指向被删除元素”的那个迭代器失效，其它迭代器不受任何影响；
3)：list 迭代器的设计代码如下：
template <class T, class Ref, class Ptr>
struct __list_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 self& x) : node(x.node) {}
bool operator==(const self& x) const { return node == x.node; }
bool operator!=(const self& x) const { return node != x.node; }
//以下对迭代器取值(deference)，取的是节点的数据值
reference operator*() const { return node->data; }
//以下是迭代器的成员存取(member access)运算符的标准做法
pointer operator->() const { return &(operator*()); }
//对迭代器累加 1，就是前进一个节点
//++self;
self& operator++() {
node = node->next;
return *this;
}
//self++;
self operator++(int) {
self tmp = *this;
++*this;
return tmp;
}
//对迭代器递减 1，就是后退一个节点
//--self
self& operator--() {
node = node->prev;
return *this;}
//self--
self operator--(int) {
self tmp = *this;
--*this;
return tmp;
}
};4：list 的数据结构
1：SGI 中 list 不仅是一个双向链表，而且还是一个环状双向链表，所以它只需要一个指针，便可以完整表现整个链表：
template <class T, class Alloc = alloc>
class list {
protected:
typedef __list_node<T> list_node;
public:
typedef __list_iterator<T, T&, T*> iterator;
typedef list_node* link_type
protected:
link_type node; // 只要一个指针，便可表示整个环状双向链表
...
};如果让指针 node 指向刻意置于尾端的一个空白节点，node 便能符合 STL 对 “前闭后开” 区间的要求，成为 last 迭代器，这么一来，以下几个函数便都可以轻易完成；
iterator begin() { return node -> next; }
iterator end() { return node; }
bool empty() { return begin() == end(); }
size_type size() const {
size_type result = 0;
result = distance(begin(), end()); //全局函数，第3章
return result;
}
//取头节点的内容（元素值）
reference front() { return *begin(); }
const reference front() const { return *begin(); }
//取尾节点的内容（元素值）
reference back() { return *(--end()); }
const reference back() const { return *(--end()); }5：list 的构造与内存管理：constructor，push_back，insert
1)：list 默认使用 alloc 作为空间配置器，并据此另外定义了一个 list_node_allocator，为的是更方便地以节点大小为配置单位：
template <class T, class Alloc = alloc>
class list {
protected:
typedef __list_node<T> list_node;
typedef simple_alloc<list_node, Alloc> list_node_allocator;
};2)：于是，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(cost T& value) {
link_type p = get_node();
construct(&(p->data), value);
return p;
}
//撤销(析构并释放一个节点)
void destroy_node(link_type p) {
destroy(&(p->data));
put_node(p);
}3)：list 提供有许多 constructors，其中一个是 default constructor，允许我们不指定任何参数做出一个空的 list 出来；
protected:
void empty_initialize() {
node = get_node(); //配置一个节点空间
node->next = node;
node->prev = node;
}
public:
list() { empty_initialize(); }4)：list 的push_back()函数代码如下：
public:
void push_back(const T& value) { insert(end(), value); }
//在迭代器 position 所指位置之前插入一个节点，内容为 value
iterator insert(iterator position, const T& value) {
link_type tmp = create_node(value); //产生一个节点（设定内容 value)
tmp->next = position.node;
tmp->prev = position.node->prev;
(position.node->prev)->next = tmp;
position.node -> prev = tmp;
return tmp;
}6：list 元素的其它操作 erase(), clear(), remove(), unqiue(), transfer(), splice(), merge(), sort()
1)：iterator erase(iterator position)操作表示移除迭代器 position 所指节点，返回 position 的下一个节点，代码如下：
public:
//移除迭代器 position 所指节点，返回 position 的下一个节点
iterator erase(iterator position) {
link_type next_node = position.node -> next;
link_type prve_node = position.node -> prev;
prev_node -> next = next_node;
next_node->prev = prev_node;
destropy_node(position.node)
return next_node;
}2)：void clear()函数清除 list 的所有节点（整个链表）
public:
//清除所有节点(整个链表）
void clear() {
link_type cur = node->next; //头节点
while (cur != node){ //遍历每一个节点
link_type tmp = cur;
destroy_node(tmp); //撤销一个节点
cur = cur->next;
}
//恢复 node 的原始状态
node->next = node;
node->prve = node;
}3)：void remove(const T& value)将数值为 value 的所有节点移除，代码如下：
public:
//将数值为 value 的所有节点删除
void remove(const T& value) {
iterator first = begin();
iterator last = end();
while (first != last) { //遍历每一个节点
iterator next = first;
++next;
if (*first == value) erase(first); //找到就删除
first = next;
}
}4)：void unqiue()移除数值相同的元素，注意，只有“连续而相同的元素”才会被移除剩一个，代码如下：
public:
void unique() {
iterator first = begin();
iterator last = end();
if (first == last) return;
while(first != last) { //遍历每一个节点
iterator next = first;
++next;
if((next != last) && (*first == *next))
erase(first);
first = next;
}
}5)：void transfer(iterator position, iterator first, iterator last)函数将[first, last)内的所有元素移动到 position 之前。该操作是 list 的其它操作如splice，sort，merge 操作的基础。代码如下
protected:
//将[first, last) 内的所有元素移动到 position 之前
void transfer(iterator position, iterator first, iterator last){
if (position != last) {
(last.node->prev)->next = position.node;
(first.node->prev)->next = last.node;
(position.node->prev)->next = first.node;
link_type tmp = position.node->prev;
position.node->prev = last.node->prev;
last.node->prev = first.node->prev;
first.node->prev = tmp;
}
}6)：void splice()接合操作是将某连续范围的元素从一个 list 移动到另一个（或同一个）list 的某个定点，其有三个版本，代码如下：
public:
//将整个链表 tmp 接合于 position 所指位置之前
void splice(iterator position, list& tmp) {
if (!tmp.empty()) {
transfer(position, tmp.begin(), tmp.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);
}7)：void merge()函数将链表 tmp 合并到 *this 身上，两个 list 的内容都必须先经过递增排序
public:
//merge() 将 tmp 合并到 *this 身上，两个 lists 的内容都必须先经过递增排序
void merge(list& tmp){
iterator first1 = begin();
iterator last1 = end();
iterator first2 = tmp.begin();
iterator last2 = tmp.end();
//注意：前提是两个 lists 都已经经过递增排序
while (first1 != last1 && first2 != last2){
if (*first2 < *first1){
iterator next = first2;
trnasfer(first1, first2, ++next2);
first2 = next;
}
else
++first1;
}
if (first2 != last2) transfer(last1, first2, last2);
}8)：void reverse()将链表逆向重置，代码如下：
public:
// reverse() 将 *this 的内容逆向重置
void reverse() {
//首先判断是否是空链表或者只有一个元素
if (node->next == node || node->next->next == node)
return;
iterator first = begin();
++first;
while (first != end()) {
iterator next = first;
++next;
transfer(begin(), first, next);
first = next;
}
}9)：void sort()操作是将 list 的元素排序，所用的排序为归并排序(merge sort)，不能使用 STL 算法 sort()，因为 STL 中的 sort()只接受 RandomAccessIterator：
public:
//使用的是 merge sort
void sort() {
if (node->next == node || node->next->next == node)
return;
//一些新的 lists，作为中介数据存放区
list carry;
list 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])
} 
扫一扫
2412
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
