1.list的数据结构
STL中的list不仅仅是一个双向链表,而且还是一个环状链表。所以它只需要一个指针就可以完整表现整个链表。
list中有一个属性node指针,刻意指向了尾端的一个空白节点,这样就符合STL前开后闭区间,并且以下几个函数就交容易实现。
iterator begin(){return (link_type)((node*).next);}
iterator end(){return node;}
相对与vector的start,finish,list只需要一个属性node就能完成应有功能了。
2.list的操作
2.1. push_front和push_back
双向链表,可以双向插入
2.2. pop_front和pop_back
vector是没有pop_*操作的,但是list有
2.3. erase
list的erase没有vector那么的复杂就是直观的删除元素。
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)
{
while (first != last) erase(first++);
return last;
}
2.4. clear
与vector不同list的clear是遍历元素摧毁并收回空间的。
void 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;
}
2.5. remove
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;
}
}
2.6. unique
unique操作不是使得list中没有元素都独一无二,而是删除相同的连续元素,注意只有“连续且相同的元素”,才会被移除剩一个。
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;
}
}
2.7. transfer
transfer并不是公开接口,而是list内部提供的一个所谓的迁移操作:将某连续范围内的元素迁移到某个特定位置之前。这个操作对splice,reverse,sort都很有帮助。技术上就是指针的移动而已:
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)
}
}
2.8. splice
和transfer的效果类似,但是transfer是内部的算法,splice是对外的接口,所以splice的参数中为保证后面所用的迭代器范围版本有效,另外还有一个参数是迭代器范围所属的list的引用。
// 将 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)可指向同一个ist,
// 但position不能位于[first,last)之內。
void splice(iterator position, list&, iterator first, iterator last)
{
if (first != last)
transfer(position, first, last);
}
2.9. reverse
由于list是双向链表,所以reverse使用了插入法,而不是单链表常用的三指针法。
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);
}
}
2.10. merge
merge操作是将x合并到*this上,两个list的内容都必须先经过递增排序
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);
}
2.11. sort
sort就是排序,但是list容器内自己定义了sort,这是因为list的迭代器是Bidirectional Iterator,而sort算法要求的是Random Access Iterator。所以对list进行排序不可以调用算法库的sort而需要调用list自带的接口sort。list的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]);
}
2.12. assign和swap
当然list也有assign和swap操作。