STL源码剖析笔记：Vector、List

STL 六大组件

1. 容器 containers：用来存放数据，如vector、list、deque、set、map
2. 算法 algorithms：sort、search、copy、erase
3. 迭代器 iterators：泛型指针。
4. 仿函数 functors：行为类似函数，可作为算法的某种策略。
5. 配接器 adapters：用以修饰容器、仿函数、迭代器接口的东西。例如 queue和stack所有操作都由底层的deque供应。
6. 配置器 allocators：负责空间配置与管理。

顺序容器的选择原则：主要看访问操作更多，还是插入删除更多

1. 一般使用vector
2. 有很多小元素，且空间额外开销很重要，不要使用链表
3. 需要随机访问元素，用vector或deque
4. 需要在容器中间插入删除元素，用链表
5. 在头尾插入删除，但不会在中间插入删除，用deque

一、Vector

特点：连续线性空间

<stl_vector.h>

typedef T value_type;
typedef value_type* pointer;
typedef value_type* iterator;     //vector的迭代器是普通指针 => vector<int>::iterator ite;   ite的类型是int*
typedef value_type& reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;

iterator start;                   //空间头
iterator finish;                  //空间尾
iterator en_of_storage;     //可用空间尾

iterator begin() {return start;}
iterator end() {return finish;}
size_type size() const {return size_type(end()-begin());}
size_type capacity() const {return size_type(end_of_storage-begin());}
bool empty() const {return begin() == end();}
reference operator[] (size_type n){return *(begin()+n);}

reference front(){return *begin();}         //第一个元素
reference back(){return *(end()-1);}      //最后一个元素
void push_back(const T& x){                  //将元素插入尾端
    if(finish != end_of_storage){
        construct(finish,x);      //要构造，C++11新增 emplace_back() 直接在容器尾部创建不用构造
        ++finish;
    }
    else
        insert_aux(end(),x);
}     
void pop_back(){                                   //尾端元素取出
    --finish;
    destory(finish);
}   
iterator erase(iterator position){             //清除某位置上的元素
    if(position+1 != end())
        copy(positon+1,finish,position);     //后续元素往前移动
    --finish；
    destory(finish);
    return position;
}
void resize(size_type new_size, const T& x){
    if(new_size<size())
        erase(begin()+new_size,end());
    else
        insert(end(),new_size-size(),x);    
}
void resize(size_type new_size) {resize(new_size,T());}
void clear() {erase(begin(),end());}

Q. 增加新元素时超容会怎样？

A. 增加新元素时，如果超容，会重新配置一块2倍容量的空间。（为什么要重新配置？因为无法保证原空间还有可使用的连续内存空间）

然后将原内容拷贝到新空间，再构造新元素。

最后释放原空间。

时间复杂度：

插入	删除	访问
push_back O(1)	pop_back O(1)	O(1)
insert O(n)	erase O(n)

注意：插入操作要注意，一旦引起空间重新配置，指向原vector的迭代器就失效了。

 

二、List

特点：空间不连续；插入删除永远是常数时间；访问效率低。

注意：list节点和list本身是不同的结构

//双向链表
struct __list_node{      
    typedef void* void_pointer;
    void_pointer prev;    
    void_pointer next;
    T data;
}

//双向迭代器
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节点

    ...
}

//list 是一个双向环状链表，一个指针就可以遍历
typedef __list_node<T> list_node;
typedef list_node* link_type;
link_type node;     //指向尾端空白节点，符合“前闭后开”

iterator begin() {return (link_type)((*node).next);}
iterator end() {return node;}
bool empty() {return node->next == node;}
size_type size() const {
    size_type result=0;
    distance(begin(),end(),result);
    return result;
}
reference front() {return *begin();}
reference back() {return *(--end());}

void push_front(const T& x) {insert(begin(),x);}
void push_back(const T& x) {insert(end(),x);}
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_ndoe;
    destory_node(position.node);
    return iterator(next_node);
}
void pop_front() {erase(begin());}
void pop_back() {
    iterator tmp = end();
    erase(--temp);
} 
void list<T,Alloc>::clear(){           //清空链表
    link_type cur = (link_type) node->next;
    while(cur != node){
        link_type tmp = cur;
        cur = (link_type) cur->next;
        destory_node(tmp);
    }
    node-> next = node;
    node -> prev = node;
}
void list<T,Alloc>::remove(const T& value){   //移除所有值为value的元素
    iterator first = begin();
    iterator last = end();
    while(first != last){
        iterator next = first;
        ++next;
        if(*first == value) erase(first);
        first = next;
    }
}
void list<T,Alloc>::unique(){                     //数值相同的连续元素只保留1个
    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：

//将[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;   
    }
}

接合  splice

 merge()、reverse()、sort()

 

  Q. vector可以用普通指针做迭代器，list可以吗？

A. 不行，因为vector内存连续所以可以。list内存不连续，list是一个双向链表，迭代器要具备前移、后移，所以list是双向迭代器(Bidirectional iterator)。

 时间复杂度：

插入	删除	访问
push_front O(1)	pop_front O(1)	O(n)
push_back O(1)	pop_back O(1)
insert O(1)	erase O(1)