【STL】list的简单剖析以及各种函数的实现

STL中的list是比较常用的容器，对于任何位置的元素插入或元素移除，list永远是常数。

list中的迭代器在插入和删除后，仍然有效,但是耦合操作splice操作可能使迭代器失效，而vector就不成立了。

list节点

template <class T>
struct __list_node {
    typedef void* void_pointer;
    void_pointer prev; // 类型为void*。其实可设为 __list_node<T>*
    void_pointer next;
    T data;
};
 
 
1
2
3
4
5
6
7
 
 
1
2
3
4
5
6
7

显然这是一个双向链表，但其实是一个环状的双向链表 
只需要一个指针，就可以完整的表现整个链表。 
所以添加一个node节点，放置在尾端，符合前闭后开的区间， 
这样是迭代器begin和end比较好完成。

4个构造

(1)explicit list ( const Allocator& = Allocator() );
(2)explicit list ( size_type n, const T& value = T(), const Allocator& = Allocator() );
(3)template < class InputIterator >
         list ( InputIterator first, InputIterator last, const Allocator& = Allocator() );
(4)list ( const list<T,Allocator>& x );
 
 
1
2
3
4
5
 
 
1
2
3
4
5

(1)是默认的构造函数，构造一个空的list对象，with no content and a size of zero。 
空的list，前驱指向后继，后继指向前驱

(2)构造有n个T对象的list。 
(3)迭代器的构造函数，区间[first,last),左闭右开 
注迭代器构造函数的参数还可以用数组，可测试用例 
(4)拷贝构造函数，

测试代码

// constructors used in the same order as described above:
  list<int> first;                                // empty list of ints
  list<int> second (4,100);                       // four ints with value 100
  list<int> third (second.begin(),second.end());  // iterating through second
  list<int> fourth (third);                       // a copy of third

  // the iterator constructor can also be used to construct from arrays:
  int myints[] = {16,2,77,29};
  list<int> fifth (myints, myints + sizeof(myints) / sizeof(int) );

  cout << "The contents of fifth are: ";
  for (list<int>::iterator it = fifth.begin(); it != fifth.end(); it++)
    cout << *it << " ";

  cout << endl;

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

迭代器操作函数：begin，end，rbegin，rend

begin和end

看上面list的节点的设计，知道有个头结点node放置在list的尾部，起始位置前驱指向node，list的尾指向node，node的前驱指向尾，后继指向起始节点。

所以begin和end函数中设计、前闭后开

iterator begin() {return (link_node*)((*node).next)}
iterator end() {return node;}
 
 
1
2
 
 
1
2

rbegin和rend

rbegin的位置相当于end的位置， 
rend的位置相当于begin的位置。

Capacity操作函数

empty函数

看node节点的后继是否指向自己

bool empty()const { return node->next == node;}
 
 
1
 
 
1

size函数 
返回lis的元素的个数

size_t size()const
{
    size_t result = 0;
    distance(begin(),end(),result);//全局函数，计算元素个数
    return result;
}
 
 
1
2
3
4
5
6
 
 
1
2
3
4
5
6

max_size和resize函数

max_size返回list中最大能包含元素个数。

reszie函数改变list中size的大小。 
如果参数sz大于max_size，那么用c来构造； 
如果参数sz小于max_size，那么进行切割。

void resize ( size_type sz, T c = T() );
 
 
1
 
 
1

测试

  list<int> mylist;

  unsigned int i;

  // set some initial content:
  for (i=1;i<10;i++) mylist.push_back(i);

  mylist.resize(5); //1 2 3 4 5
  mylist.resize(8,100);// 1 2 3 4 5 100 100 100
  mylist.resize(12); // 再加4个0

    //mylist contains: 1 2 3 4 5 100 100 100 0 0 0 0
  cout << "mylist contains:";
  for (list<int>::iterator it=mylist.begin();it!=mylist.end();++it)
    cout << " " << *it;

  cout << endl;

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Element access: front函数和back函数

利用那个node节点

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

reference back() {return *(--end());}
 
 
1
2
3
 
 
1
2
3

Modifiers:函数

先介绍insert函数和erase函数，这两个函数比较重要。

insert函数

insert函数其实是在pos位置之前插入元素的，返回的是新插入元素的 位置(看函数的实现)，但是pos位置仍然为之前节点的位置(看测试代码)

iterator insert ( iterator position, const T& x );
    void insert ( iterator position, size_type n, const T& x );
template <class InputIterator>
    void insert ( iterator position, InputIterator first, InputIterator last );
 
 
1
2
3
4
 
 
1
2
3
4

iterator insert ( iterator position, const T& x )
{
    link_node* tmp = create_node(x);//创建新的节点。
    //调整指针，使tmp插入进去
    tmp->next = position.next;
    tmp->prev = position.node->prev;
    (link_node*(position.node->prev))->next = tmp;
    position.node->prev = tmp;
    return tmp;
}
 
 
1
2
3
4
5
6
7
8
9
10
 
 
1
2
3
4
5
6
7
8
9
10

测试

list<int> mylist;
  list<int>::iterator it;

  // set some initial values:
  for (int i=1; i<=5; i++) mylist.push_back(i); // 1 2 3 4 5

  it = mylist.begin();
  ++it;       // it points now to number 2           

  mylist.insert (it,10);   // 1 10 2 3 4 5
    //注意看这
  // "it" still points to number 2                      
  mylist.insert (it,2,20);                      // 1 10 20 20 2 3 4 5

  --it;       // it points now to the second 20            

  vector<int> myvector (2,30);
  mylist.insert (it,myvector.begin(),myvector.end());
  // 1 10 20 30 30 20 2 3 4 5

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

erase函数

返回pos位置的下一个节点，pos变成next_node；即删除后两个表示的一样节点

iterator erase ( iterator position );
iterator erase ( iterator first, iterator last );
 
 
1
2
 
 
1
2

//移除pos位置的节点
iterator erase ( iterator pos)
{
    link_node *next_node = (link_node*)pos.node->next;
    link_node *prev_node = (link_node*)pos.node->prev;
    prev_node->next = next_node;
    next_node_>prev = prev_node;
    destroy_node(pos.node);
    return iterator(next_node);
}

 
 
1
2
3
4
5
6
7
8
9
10
11
 
 
1
2
3
4
5
6
7
8
9
10
11

测试

int main ()
{
  unsigned int i;
  list<unsigned int> mylist;
  list<unsigned int>::iterator it1,it2;

  // set some values:
  for (i=1; i<10; i++) mylist.push_back(i*10);

                              // 10 20 30 40 50 60 70 80 90
  it1 = it2 = mylist.begin(); // ^^
  advance (it2,6);            // ^                 ^
  ++it1;                      //    ^              ^

  it1 = mylist.erase (it1);   // 10 30 40 50 60 70 80 90
                              //    ^           ^

  it2 = mylist.erase (it2);   // 10 30 40 50 60 80 90
                              //    ^           ^

  ++it1;                      //       ^        ^
  --it2;                      //       ^     ^

  mylist.erase (it1,it2);     // 10 30 60 80 90
                              //        ^

  cout << "mylist contains:";
  for (it1=mylist.begin(); it1!=mylist.end(); ++it1)
    cout << " " << *it1;
  cout << endl;
 //mylist contains: 10 30 60 80 90
  return 0;
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

push_back、push_front函数

调用insert函数

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

void push_back(const T& x){ insert(end(),x);}
 
 
1
2
3
 
 
1
2
3

pop_back、pop_front函数

调用erase函数

void pop_front () { erase(begin());}

void pop_back() 
{
    iterator tmp = end();
    erase(--tmp);
}

 
 
1
2
3
4
5
6
7
8
 
 
1
2
3
4
5
6
7
8

assign函数

重新写list，Assign new content to container，就像构造函数一样。

template <class InputIterator>
  void assign ( InputIterator first, InputIterator last );
void assign ( size_type n, const T& u );
 
 
1
2
3
 
 
1
2
3

list<int> first;
  list<int> second;

  first.assign (7,100);                      // 7 ints with value 100

  second.assign (first.begin(),first.end()); // a copy of first

  int myints[]={1776,7,4};
  first.assign (myints,myints+3);            // assigning from array
 
 
1
2
3
4
5
6
7
8
9
 
 
1
2
3
4
5
6
7
8
9

swap函数 
Swap content，交换两个list

void swap ( list<T,Allocator>& lst );
 
 
1
 
 
1

  list<int> first (3,100);   // three ints with a value of 100
  list<int> second (5,200);  // five ints with a value of 200
  list<int>::iterator it;

  first.swap(second);
  //first contains: 200 200 200 200 200 
  //second contains: 100 100 100 
 
 
1
2
3
4
5
6
7
 
 
1
2
3
4
5
6
7

clear函数 
清除整个链表

void clear()
{
 link_node *cur =(link_node*)node->next;//起始位置
 while(cur != node)
 {
   link_node *tmp = cur;
   cur = cur->next;
   destroy_node(tmp);
 }
 //恢复node原始状态，
 node->next = node;
 node->prev = node;

}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Operations函数

void reverse ( );
//Reverse the order of elements
 
 
1
2
 
 
1
2

remove 
Remove elements with specific value 
//删除所有的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;
 }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13

unique函数 
//移除数值相同的连续元素，只有相同连续的元素，才会被移除剩一个

void 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;//修正区段，如果删除了，next指向下一个区域
 }
}

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

splice,sort,merge、reverse

这四个函数都需要调用，list内部提供的一个所谓的迁移操作(transfer)：将某连续范围的元素迁移到某个特定位置之前，就是一个指针的移动。

transfer函数 
可以是同一个list，也可以是两条list

//将[first,last)内的所有元素都移到pos之前

//注：区间是左闭右开的，将first到last前一个插入pos之前
void transfer(iterator pos,iterator first,iterator last)
{
    //last等于pos，就不用移动
    if(pos != last)
    {
        //1-4从左向右断开
        //(1)将last的前一个节点后继指向pos位置
        (*((link_node*)(*last.node).prev)).next = pos.node;
        //(2)将firt到last摘出去
        (*((link_node*)(*fisrt.node).prev)).next = last.node;
        //(3)将摘出去的连接到pos之前
        (*((link_node*)(*pos.node).prev)).next = frst.nod;

        //从右向左链接
        //(4)标记pos之前的节点，因为(5)断开后找不到这个位置
        link_node* tmp = link_node*((*pos.node).prev);
        //(5)pos前驱指向last之前的节点
        (*pos.node).prev = (*last.node).prev;
        //(6)完全摘出去，last前驱指向fist之前的节点
        (*last.node).prev = (*first.node).prev;
        //(7)将frst节点连接到pos之前的tmp节点
        (*first.node).prev = tmp;

    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

reverse 
将list中的原序列元素反序，调用transfer，

void reverse()
{
    //链表为空或者只有一个元素，什么不做
    //这样判断，速度较快
    if(node->next == node || (node->next)->next == node)
        return;

    iterator first = begin();
    ++first;//此时first指向第二个元素
    //
    while(first != end())
    {
        iterator old = first;
        ++first;
        //将后面的元素全部插入第一个元素之前。
        transfer(begin(),old,first);        
    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

splice函数

list提供的公共接口来将某些连续方位的元素从一个list移动到另一个list，封装了transfer。 
另一个list中的元素已经被移走，

void splice ( iterator position, list<T,Allocator>& x );//移动整个x
void splice ( iterator position, list<T,Allocator>& x, iterator i );//只移动一个元素
void splice ( iterator position, list<T,Allocator>& x, iterator first, iterator last );
 
 
1
2
3
 
 
1
2
3

测试

list<int> mylist1, mylist2;
  list<int>::iterator it;

  // set some initial values:
  for (int i=1; i<=4; i++)
     mylist1.push_back(i);      // mylist1: 1 2 3 4

  for (int i=1; i<=3; i++)
     mylist2.push_back(i*10);   // mylist2: 10 20 30

  it = mylist1.begin();
  ++it;                         // points to 2

  mylist1.splice (it, mylist2); // mylist1: 1 10 20 30 2 3 4
                                // mylist2 (empty)
                                // "it" still points to 2 (the 5th element)

  mylist2.splice (mylist2.begin(),mylist1, it);
                                // mylist1: 1 10 20 30 3 4
                                // mylist2: 2
                                // "it" is now invalid.
  it = mylist1.begin();
  advance(it,3);                // "it" points now to 30

  mylist1.splice ( mylist1.begin(), mylist1, it, mylist1.end());
                                // mylist1: 30 3 4 1 10 20

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

merge函数

注：必须两个list必须都已经递增排序，合并完后，参数x中没有元素

 void merge ( list<T,Allocator>& x )
template <class Compare>
  void merge ( list<T,Allocator>& x, Compare comp );
 
 
1
2
3
 
 
1
2
3

void merge ( list<T,Allocator>& x )
{
    iterator first1 = begin();
    iterator last1 = end();
    iteartor first2 = x.begin();
    iterator last2 = x.end();

    //注：两个list必须递增排序
    while(first1 != last1 && first2 != last2)
    {
        if(*first2 < *first1)
        {
            iterator next = first2;
            transfer(first1,fisrt2,++next);
            first2 = next;
        }
        else 
            ++first1;
    }
    if(first2 != last2)
        transfer(last1,first2,first2);
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

sort函数

list不能使用STL中的算法sort，必须使用自己的sort函数， 
因为STL中的sort函数只接收RamdonAccessIterator

  void sort ( );
template <class Compare>
  void sort ( Compare comp );
 
 
1
2
3
 
 
1
2
3

void sort()
{
    //链表为空或者只有一个元素，什么不做
    //这样判断，速度较快
    if(node->next == node || (node->next)->next == node)
        return;

    //一些新的lists，作为中结数据存储区
    list<T> carry;
    list<T> counter[64];
    int fill = 0;

    //待排序的list不为空
    while(!empty())
    {
        //将待排序的list的首元素移动到carry中
        carry.splice(carry.begin(),*this,begin());

        //将carry中的元素放在桶counter[fill]中
        int i = 0; 
        while(i < fill && !counter[i].empty())
        {
            //合并到桶中，递增有序
            counter[i].merge(carry);

            carry.swap(counter[i++]);
        }

        //i ==fill跳出循环，说明当前桶放满，放在下个桶中
        //或者当前桶没放满，放在当前桶中
        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]);
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

这段代码长度不长，但是比较难理解。

fill–当前可以处理的元素个数为2^fill个

counter[fill]–可以容纳2^(fill+1)个元素 
__counter[0]里存放2(0+1)次方个元素 1 
__counter[1]里存放2(1+1)次方个元素 4 
__counter[2]里存放2(2+1)次方个元素 8

carry–一个临时中转站，在处理的元素个数不足2^fill个时，在counteri之前转移元素

具体是显示步骤是：

1、每次读一个数据到carry中，并将carry的数据转移到counter[0]中

1)当counter[0]中的数据个数少于2时，持续转移数据到counter[0]中 
2)当counter[0]的数据个数等于2时，将counter[0]中的数据转移到counter[1]…从counter[i]转移到counter[i+1],直到counter[fill]中数据个数达到2^(fill+1)个。

2、 ++fill,重复步骤1.

注：归并排序，先将前两个归并，然后再将后两个归并，再归并程4个元素；然后再两个两个归并，归并成4个，两个4个归并成8个；归并成16个。32个。。。。。

测试

list<double> first, second;

  first.push_back (3.1);
  first.push_back (2.2);
  first.push_back (2.9);

  second.push_back (3.7);
  second.push_back (7.1);
  second.push_back (1.4);

  first.sort();
  second.sort();

  first.merge(second);

  second.push_back (2.1);

  first.merge(second,mycomparison);