stl源码剖析04——list

一、list概述

  • list的使用语法:https://blog.csdn.net/qq_41453285/article/details/105483054
  • 总的来说:环形双向链表
  • 特点:
    • 底层是使用链表实现的,支持双向顺序访问
    • 在list中任何位置进行插入和删除的速度都很快
    • 不支持随机访问,为了访问一个元素,必须遍历整个容器
    • 与其他容器相比,额外内存开销大
  • 设计目的:令容器在任何位置进行插入和删除都很快
  • 何时使用:
    • 容器需要不断地在中间插入或删除元素
    • 无论删除还是增加,list的迭代器、引用、指针都不会失效
  • 与其他容器的比较:
vector可变大小数组。支持快速随机访问。在尾部之外的位置插入或删除元素可能很慢
deque双端队列。支持快速随机访问。在头尾插入/删除速度很快
list双向链表。只支持双向顺序访问。在list中任何位置进行插入和删除的速度都很快
forward_list单向链表。只支持单向顺序访问。在链表任何位置进行插入和删除操作速度都很快
array固定大小数组。支持快速随机访问。不能添加或删除元素
string与vector相似的容器,但专门用于保存字符。随机访问快。在尾部插入或删除速度快

二、list的节点(__list_node)

  • 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;

};

 

  • 下图是结构所示的样子

三、list的迭代器

  • list不再能够像 vector一样以原生指标做为迭代器,因为其节点不保证在储存空间中连续存在
  • list迭代器必须有能力指向list的节点,并有能力做正确的递增、递减、取值、成员存取等动作。所谓“list迭代器正确的递增、递 减、取值、成员取用”动作是指:递增时指向下一个节点,递减时指向上一个节点,取值时取的是节点的数据值,成员取用时取用的是节点的成员,如下图所示:

  • 由于list是一个双向链表(double linked-list),迭代器必须具备前移、后移的能力。所以list提供的是Bidirectional Iterators
  • list有以下几个重要性质:
    • 插入动作(insert)和接合动作(splice)都不会造成原有的 list 迭代器失效。这在vector是不成立的,因为 vector的插入动作可能造成记忆体重新配置,导致原有的迭代器全部失效
    • 甚至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的节点


    // 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不仅是一个双向串行,而且还是一个环状双向链表。所以它只需要一个指针,便可以完整表现整个链表

link_type、node节点

  • node节点是指向于list最后一个节点的指针
template <class T, class Alloc = alloc> //默认使用alloc为配置器

class list {

protected:

    typedef __list_node<T> list_node;

public:

    typedef list_node* link_type;

protected:

    link_type node; // 只要一个指针,便可表示整个环状双向链表

    ...

};

 

begin()、end()等函数

  • 如果让指标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); // 全局函式,第 3章。
    
    return result;

}


// 取头节点的内容(元素值)

reference front() { return *begin(); }


// 取尾节点的内容(元素值)

reference back() { return *(--end()); }

五、list的构造与内存管理(constructor、push_back、insert)

list的内存管理(list_node_allocator)

  • list缺省使用alloc做为空间配置器,并据此另外定义了一个list_node_allocator,为的是更方便地以节点大小为配置单位:
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;

    ...

};
  • 于是,list_node_allocator(n) 表示配置n个节点空间。以下四个函数,分别用来配置、释放、建构、摧毁一个节点:
protected:

    // 配置一个节点并传回

    link_type get_node() { return list_node_allocator::allocate(); }


    // 释放一个节点

    voidput_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 提供有许多constructors,其中以个是default constructor,允许我们不指 定任何参数做出一个空的list出来:
public:

    list() { empty_initialize(); } //产生一个空链表

protected:

    void empty_initialize() {

        node = get_node(); //配置一个节点空间,令node指向它

        node->next = node; //令node头尾都指向自己,不设元素值

        node->prev = node;

    }
  • list为空时, node节点的prev、next指向于自己

push_back、insert

  • 当我们以push_back()将新元素插入于list尾端,此函数内部调用insert():
void push_back(const T& x) { insert(end(), x); }
  • 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;

}
  • 于是,如果程序连续插入了五个节点(其值为0、1、2、3、4)之后,list的状态如下图所示

  • 如果我们希望在list内的某处安插新节点,首先必须确定安插位置, 例如我希望在数据值为3的节点处插入一个数据值为99的节点,可以这么做:
ilite = find(il.begin(), il.end(), 3);

if (ilite!=0)

il.insert(ilite, 99);
  • find()操作稍后再做说明。插入之后的list状态如下图所示。注意,插入完成后, 新节点将位于标兵迭代器(标示出插入点)所指之节点的前方——这是STL对于 “插入动作”的标准规范。由于list不像vector 那样有可能在空间不足时做重新配置、数据移动的操作,所以插入前的所有迭代器在插入动作之后都仍然有效

六、list的元素操作

push_front、push_back

//插入一个节点,做为头节点

void push_front(const T& x) { insert(begin(), x); }


//插入一个个节点,做为尾节点

void push_back(const T& x) { insert(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);

}
  •  由于list是一个双向环状链表,只要我们把边际条件处理好,那么,在头部或尾部插入元素(push_front 和 push_back),动作几乎是一样的,在头部或尾部移除元素(pop_front和pop_back),动作也几乎是一样的。移除(erase) 某个迭代器所指元素,只是做一些指针搬移动作而已,并不复杂。如果上图再经以下搜寻并移除的动作,状况将如下图所示
ite = find(ilist.begin(), ilist.end(), 1);

if (ite!=0)

    cout << *(ilist.erase(ite)) << endl;

 

pop_front、pop_back 

//移除头节点

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)

    }
    
}
  • 以上七个动作,如下图所示:

splice

  • 上述的transfer并非公开接口。 list公开提供的是所谓的接合动作(splice):将某连续范围的元素从一个list搬移到另一个(或同一个)list 的某个定点
  • 下面是一个演示案例:
int iv[5] = { 5,6,7,8,9 };

list<int> ilist2(iv, iv+5);


//假设ilist的内容为0 2 99 3 4

ite = find(ilist.begin(), ilist.end(), 99);


ilist.splice(ite,ilist2); // 0 2 5 6 7 8 9 99 3 4

ilist.reverse(); // 4 3 99 9 8 7 6 5 2 0

ilist.sort(); // 0 2 3 4 5 6 7 8 9 99
  • 很容易便可看出效果。下图显示接合动作。技术上很简单,只是节点间的指针移动而已,这些动作已完全由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(), reverse(), sort()的源码。有了transfer()在手,这些动作都不难完成

merge()

// 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() 

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

    }

}

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

 

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:岁月 设计师:pinMode 返回首页
评论
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值