SGISTL源码探究-list容器(下)

前言

在上一小节我们主要介绍了list容器的迭代器及数据结构还有结点的分配及释放,构造和析构函数以及一些简单的操作。在本小节中我们将继续分析list容器提供的一些常见操作。

insert

之前关于list的构造函数的源码中都调用了insert函数,接下来,我们就来分析它,要记得,STL规定insert函数都是向前插入。
它有多个重载版本。

在指定位置前插入一个结点

iterator insert(iterator position, const T& x) {  //申请并构造一个值为x的结点  link_type tmp = create_node(x);  /* 在position前插入结点tmp */  tmp->next = position.node;  tmp->prev = position.node->prev;  (link_type(position.node->prev))->next = tmp;  position.node->prev = tmp;  //返回指向新插入结点的迭代器  return tmp;}

还有一个版本是不指定插入结点的值的,即调用默认的构造函数。

iterator insert(iterator position) { return insert(position, T()); }

在position前插入[first, last)迭代器指向的元素

template <class InputIterator>void insert(iterator position, InputIterator first, InputIterator last){  /* 利用insert向前插入的特性   * 每次都朝position插入   */  for( ; first != last; ++first)    insert(position, *first);}

在position前插入n个值为x的元素

由于n可能有不同的数据类型,所以有多个重载版本,不过最后都强转成size_type进行操作。

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);}

insert(iterator pos, size_type n, const T& x)实现部分

template <class T, class Alloc>void list<T, Alloc>::insert(iterator position, size_type n, const T& x) {  /* 由于insert的特性在position指定的位置前面插入   * 所以调用n次insert就行了   */  for ( ; n > 0; --n)    insert(position, x);}

最后,根据这些不同的版本,其实最核心的就是insert(iterator position, const T& x)函数,其他版本内部都调用了该函数。

transfer

该函数的作用是将[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;  }}

看起来有点复杂,我们一步一步来分解它。
1. (*(link_type((*last.node).prev))).next = position.node;:将最后一个元素的next指向position对应的结点。
相当于把[first, last)这一堆链表尾部与原来链表的连续切断了一半(还剩一半有*last.prev连着[first, last))
2. (*(link_type((*first.node).prev))).next = last.node;:接着将first指向的结点的前驱结点的next指针指向last。
相当于把[first, last)这一堆链表首部与原来链表的联系切断了一半(还剩一半有*first.node.prev连着原来的链表)
3. (*(link_type((*position.node).prev))).next = first.node;:将position指向的结点的前驱结点的next指针指向first指向的结点。
相当于首部已经连接了一半了,剩下还需要将
4. link_type tmp = link_type((*position.node).prev);:声明一个中间变量保存position指向的结点的前驱指针
5. (*position.node).prev = (*last.node).prev;:接着将position指向的结点的前驱指针指向last结点的前驱结点(即需要转移的链表的最后一个元素)。这样就将尾部也连接了一半了。
6. (*last.node).prev = (*first.node).prev;:将last指向的结点的前驱指针指向first指向的前驱结点。这样就将原链表腾出了一大半了。最后只需将第2步中剩下的另一半*first.node.prev指向tmp即可。
7. (*first.node).prev = tmp;:将first指向的结点的前驱指针指向position原来的前驱结点。前面要保存下来是因为在第5步的时候改变了*position.node.prev的值,如果不保存,将丢失position前面的链表。

建议对照着步骤自己画一下图,这样有助于理解。

splice

该函数的作用是拼接。
有多个重载版本,版本的不同导致其具体的功能也不同。

splice(iterator position, list& x)

该函数的作用是将x拼接到position前。
源码如下:

void splice(iterator position, list& x) {  //调用transfer将x移动到position前  if (!x.empty())    transfer(position, x.begin(), x.end());}

void splice(iterator position, list&, iterator i)

该函数的作用是将迭代器i所指的元素拼接到position前。
源码如下:

void splice(iterator position, list&, iterator i) {  iterator j = i;  ++j;  //若position和i指向的元素相同或者i指向的元素本来就在position前面,直接return  if (position == i || position == j) return;  //否则将[i, j)移动到position前  transfer(position, i, j);}

void splice(iterator position, list&, iterator first, iterator last)

该函数的作用是将[first, last)范围内的元素拼接到position前

void splice(iterator position, list&, iterator first, iterator last) {  if (first != last)    transfer(position, first, last);}

很明显position不能位于[first, last)之间,否则transfer会出错。

remove

该函数的作用是将list中的所有值为value的结点都移除。
源码如下:

template <class T, class Alloc>void list<T, Alloc>::remove(const T& value) {  iterator first = begin();  iterator last = end();  //遍历整个list  while (first != last) {    iterator next = first;    ++next;    //若等于,则调用erase删除该元素    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) {    /* 比较前后两个元素的值     * 若相等,则进行删除     * 否则移动first迭代器,跟进到next     */    if (*first == *next)      erase(next);    else      first = next;    /* 可能会因为erase删除操作使next失效     * 所以需要更新next,保持与first指向相同元素     */    next = first;  }}

merge

该函数的作用是将list x合并到该list上,合并的顺序是递增排序,并且要求合并前,两个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();  //两个链表还没到结尾  while (first1 != last1 && first2 != last2)    /* 若*first2 < *first1     * 则将first2指向的元素移动到first1指向的元素前面     * 否则first1++,寻找下一个插入点     */    if (*first2 < *first1) {      iterator next = first2;      transfer(first1, first2, ++next);      first2 = next;    }    else      ++first1;  /* 若first2 != last2   * 证明x的元素还没全部被移动到list上   * 将剩余的元素移动到last1前面   */  if (first2 != last2) transfer(last1, first2, last2);}

reverse

该函数将list逆置,即逆转链表

template <class T, class Alloc>void list<T, Alloc>::reverse() {  //空list直接返回  if (node->next == node || link_type(node->next)->next == node) return;  /* 以下便是链表逆置操作   * 先把first++是因为第一个元素并不需要动   * 只需要把后面的元素依次搬到第一个元素前就行了   * 还是借助了transfer操作   */  iterator first = begin();  ++first;  while (first != end()) {    iterator old = first;    ++first;    transfer(begin(), old, first);  }}    

sort

该函数用于对list进行排序。list容器不能使用STL中对sort算法,因为sort算法只支持random_access_iterator_tag型的迭代器。
所以只好自己声明一个了。

template <class T, class Alloc>void list<T, Alloc>::sort() {  //空list,直接返回  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]);}

一些操作符重载函数

operator ==

template <class T, class Alloc>inline bool operator==(const list<T,Alloc>& x, const list<T,Alloc>& y) {  typedef typename list<T,Alloc>::link_type link_type;  link_type e1 = x.node;  link_type e2 = y.node;  link_type n1 = (link_type) e1->next;  link_type n2 = (link_type) e2->next;  //依次比较结点的值  for ( ; n1 != e1 && n2 != e2 ;          n1 = (link_type) n1->next, n2 = (link_type) n2->next)    if (n1->data != n2->data)      return false;  //若最后长度也相等,就返回true,否则返回false  return n1 == e1 && n2 == e2;}

operator =

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++;    /* 当x已经先遍历完了,则将list多余的元素删掉     * 否则需要插入新的元素     */    if (first2 == last2)      erase(first1, last1);    else      insert(last1, first2, last2);  }  return *this;}

注意需要返回引用,否则无法连续赋值。

小结

本小节主要介绍了关于list容器的大部分操作。由于它使用的数据结构是双向链表,可能就需要你对链表比较熟悉了,特别是transfer函数的理解,还有sort函数,sort函数的操作确实比较复杂,这是也不多讲了,反而越讲越乱。
下一节我们将分析deque容器,它的数据结构稍微比list还有vector都要复杂一些。