【STL】Lists

Lists(雙向鏈表)

list :list是一種序列式容器。list容器完成的功能實際上和數據結構中的雙向鏈表是極其相似的,list中的數據元素是通過鏈表指針串連成邏輯意義上的線性表,也就是list也具有鏈表的主要優點.。即任一位置進行元素的插入、刪除操作都是快速的,但如同鏈表的缺點,list並不能提供高效的數據隨機訪問。

list的結構:list的每個節點有三個域:前驅元素指針域、數據域和後繼元素指針域。前驅元素指針域保存了前驅元素的首地址;數據域則是本節點的數據;後繼元素指針域則保存了後繼元素的首地址。

list 的常用函數:

構造函數:
list() 聲明一個空列表;
list(n) 聲明一個有n個元素的列表,每個元素都是由其默認構造函數T()構造出來的。
list(n,val) 聲明一個由n個元素的列表,每個元素都是由其複製構造函數T(val)得來的。
list(n,val) 聲明一個和上面一樣的列表。
list(first,last) 聲明一個列表,其元素的初始值來源於由區間所指定的序列中的元素。

普通函數:
begin()和end():通過調用list容器的成員函數begin()得到一個指向容器起始位置的iterator,可以調用list容器的 end() 函數來得到list末端下一位置,相當於:int a[n]中的第n+1個位置a[n],實際上是不存在的,不能訪問,經常作爲循環結束判斷結束條件使用。

push_back() 和push_front():使用list的成員函數push_back和push_front插入一個元素到list中。其中push_back()從list的末端插入,而 push_front()實現的從list的頭部插入。

empty():利用empty() 判斷list是否爲空。

resize(): 如果調用resize(n)將list的長度改爲只容納n個元素,超出的元素將被刪除,如果需要擴展那麼調用默認構造函數T()將元素加到list末端。如果調用resize(n,val),則擴展元素要調用構造函數T(val)函數進行元素構造,其餘部分相同。

clear(): 清空list中的所有元素。

front()和back(): 通過front()可以獲得list容器中的頭部元素,通過back()可以獲得list容器的最後一個元素。但是有一點要注意,就是list中元素是空的時候,這時候調用front()和back()會發生什麼呢?實際上會發生不能正常讀取數據的情況,但是這並不報錯,那我們編程序時就要注意了,個人覺得在使用之前最好先調用empty()函數判斷list是否爲空。

pop_back和pop_front():通過刪除最後一個元素,通過pop_front()刪除第一個元素;序列必須不爲空,如果當list爲空的時候調用pop_back()和pop_front()會使程序崩掉。

assign():具體和vector中的操作類似,也是有兩種情況,第一種是:l1.assign(n,val)將 l1中元素變爲n個T(val)。第二種情況是:l1.assign(l2.begin(),l2.end())將l2中的從l2.begin()到l2.end()之間的數值賦值給l1。

swap():交換兩個鏈表(兩個重載),一個是l1.swap(l2); 另外一個是swap(l1,l2),都可能完成連個鏈表的交換。

reverse():通過reverse()完成list的逆置。

merge():合併兩個鏈表並使之默認升序(也可改),l1.merge(l2,greater()); 調用結束後l2變爲空,l1中元素包含原來l1 和 l2中的元素,並且排好序,升序。其實默認是升序,greater()可以省略,另外greater()是可以變的,也可以不按升序排列。

List實例用法

int main()
        {

            using namespace std;


                list<int> l1;
                list<int> l2(2, 0);
                list<int>::iterator iter;
                l1.push_back(1);
                l1.push_back(2);
                l2.push_back(3);
                for (iter = l1.begin(); iter != l1.end(); iter++)
                {
                    cout << *iter << " ";
                }
                cout << endl << endl;
                if (l2.empty())
                {
                    cout << "l2 變爲空 !!";
                }
                cout << endl << endl;
                system("pause");
                return 0;

        }

List的源碼

template <class T>//普通list結點結構
struct __list_node
{
  typedef void* void_pointer;
  void_pointer next;
  void_pointer prev;
  T data;
};

//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;     //只要一個指針,便可以表示整個環狀鏈表,頭指針

};
stl_list.h 
// Filename:    stl_list.h
/* NOTE: This is an internal header file, included by other STL headers.
 *   You should not attempt to use it directly.
 */

#ifndef __SGI_STL_INTERNAL_LIST_H
#define __SGI_STL_INTERNAL_LIST_H

__STL_BEGIN_NAMESPACE

#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma set woff 1174
#endif

////////////////////////////////////////////////////////////////////////////////
// list結點, 提供雙向訪問能力
////////////////////////////////////////////////////////////////////////////////

template <class T>
struct __list_node      // list節點的結構
{
  typedef void* void_pointer;
  void_pointer next;
  void_pointer prev;
  T data;
};

///////////////////////////////////////////////////////////////////////////////
//list迭代器的設計
///////////////////////////////////////////////////////////////////////////////
template<class T, class Ref, class Ptr>
struct __list_iterator
{
  // 標記爲'STL標準強制要求'的typedefs用於提供iterator_traits<I>支持
  typedef __list_iterator<T, T&, T*>             iterator;       // STL標準強制要求
  typedef __list_iterator<T, const T&, const T*> const_iterator;
  typedef __list_iterator<T, Ref, Ptr>           self;

  typedef bidirectional_iterator_tag iterator_category;
  typedef T value_type;                                 // STL標準強制要求
  typedef Ptr pointer;                                  // STL標準強制要求
  typedef Ref reference;                                // STL標準強制要求
  typedef __list_node<T>* link_type;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;                    // STL標準強制要求

  // 這個是迭代器實際管理的資源指針
  link_type node;                  //只要一個指針,便可以表示整個環狀鏈表,頭指針

//迭代器構造函數
  __list_iterator(link_type x) : node(x) {}
  __list_iterator() {}
  __list_iterator(const iterator& x) : node(x.node) {}

  // 在STL算法中需要迭代器提供支持
  bool operator==(const self& x) const { return node == x.node; }
  bool operator!=(const self& x) const { return node != x.node; }

  // 重載operator *, 對迭代器取值,返回實際維護的數據
  reference operator*() const { return (*node).data; }

#ifndef __SGI_STL_NO_ARROW_OPERATOR
  // 如果支持'->'則重載之
  // 解釋一下爲什麼要返回地址
  // class A
  // {
  // public:
  //    // ...
  //    void fun();
  //    // ...
  // }
  // __list_iterator<A, A&, A*> iter(new A)
  // iter->fun();
  // 這就相當於調用(iter.operator())->fun();
  // 經過重載使其行爲和原生指針一致
  pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */

  // 前綴自加
  self& operator++()
  {
    node = (link_type)((*node).next);
    return *this;
  }

  // 後綴自加, 需要先產生自身的一個副本, 然會再對自身操作, 最後返回副本
  self operator++(int)
  {
    self tmp = *this;
    ++*this;
    return tmp;
  }

  self& operator--()
  {
    node = (link_type)((*node).prev);
    return *this;
  }

  self operator--(int)
  {
    self tmp = *this;
    --*this;
    return tmp;
  }
};

// 如果編譯器支持模板類偏特化那麼就不需要提供以下traits函數
// 直接使用<stl_iterator.h>中的
// template <class Iterator>
// struct iterator_traits
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION

template <class T, class Ref, class Ptr>
inline bidirectional_iterator_tag
iterator_category(const __list_iterator<T, Ref, Ptr>&) {
  return bidirectional_iterator_tag();
}

template <class T, class Ref, class Ptr>
inline T*
value_type(const __list_iterator<T, Ref, Ptr>&) {
  return 0;
}

template <class T, class Ref, class Ptr>
inline ptrdiff_t*
distance_type(const __list_iterator<T, Ref, Ptr>&) {
  return 0;
}

#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

// 默認allocator爲alloc, 其具體使用版本請參照<stl_alloc.h>
template <class T, class Alloc = alloc>
class list
{
protected:
  typedef void* void_pointer;
  typedef __list_node<T> list_node;

  // 這個提供STL標準的allocator接口
  //list缺省使用alloc作爲空間配置器並據此定義了list_node_allocator
  // 專屬之空間配置器,可以方便地每次配置一個節點大小
  typedef simple_alloc<list_node, Alloc> list_node_allocator;

public:
  typedef T value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef list_node* link_type;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

public:
  typedef __list_iterator<T, T&, T*>             iterator;
  typedef __list_iterator<T, const T&, const T*> const_iterator;

#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  typedef reverse_iterator<const_iterator> const_reverse_iterator;
  typedef reverse_iterator<iterator> reverse_iterator;
#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  typedef reverse_bidirectional_iterator<const_iterator, value_type,
  const_reference, difference_type>
  const_reverse_iterator;
  typedef reverse_bidirectional_iterator<iterator, value_type, reference,
  difference_type>
  reverse_iterator;
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

protected:
  // 使用上述的專屬空間配置器list_node_allocator(n)配置n新結點
  //以下四個函數分別用於配置、釋放、構造、銷燬一個節點

  //該函數配置一個節點並回傳
  link_type get_node() { return list_node_allocator::allocate(); }

  // 釋放指定結點, 不進行析構, 析構交給全局的destroy,
  // 見<stl_stl_uninitialized.h>
  void put_node(link_type p) { list_node_allocator::deallocate(p); }

  // 創建結點, 首先分配內存, 然後進行構造,有元素值
  // 注: commit or rollback
  link_type create_node(const T& x)
  {
    link_type p = get_node();
    __STL_TRY {
      construct(&p->data, x);  //全局函數,構造/析構基本工具
    }
    __STL_UNWIND(put_node(p));
    return p;
  }

  // 析構結點元素, 並釋放內存
  void destroy_node(link_type p)
  {
    destroy(&p->data);   //全局函數,構造/析構基本工具
    put_node(p);
  }

protected:

  void empty_initialize()
  {
    node = get_node();  //配置一個節點空間,令node指向它
    node->next = node;  //令node頭尾指向自己,不設置元素值
    node->prev = node;
  }

  // 創建值爲value共n個結點的鏈表
  // 注: commit or rollback
  void fill_initialize(size_type n, const T& value)
  {
    empty_initialize();
    __STL_TRY {
      // 此處插入操作時間複雜度O(1)
      insert(begin(), n, value);
    }
    __STL_UNWIND(clear(); put_node(node));
  }

// 以一個區間初始化鏈表
// 注: commit or rollback
#ifdef __STL_MEMBER_TEMPLATES
  template <class InputIterator>
  void range_initialize(InputIterator first, InputIterator last)
  {
    empty_initialize();
    __STL_TRY {
      insert(begin(), first, last);
    }
    __STL_UNWIND(clear(); put_node(node));
  }
#else  /* __STL_MEMBER_TEMPLATES */
  void range_initialize(const T* first, const T* last) {
    empty_initialize();
    __STL_TRY {
      insert(begin(), first, last);
    }
    __STL_UNWIND(clear(); put_node(node));
  }
  void range_initialize(const_iterator first, const_iterator last) {
    empty_initialize();
    __STL_TRY {
      insert(begin(), first, last);
    }
    __STL_UNWIND(clear(); put_node(node));
  }
#endif /* __STL_MEMBER_TEMPLATES */

protected:
  link_type node;  //這個是鏈表頭結點, 其本身不保存數據

public:
   //用於空鏈表的建立,不用指定任何參數
   //empty_initialize()函數的實現在是上面
list() {     empty_initialize(); } 
iterator begin() {     return (link_type)((*node).next); } 
const_iterator begin() const {     return (link_type)((*node).next); }

//讓頭節點node指向可以置於尾端的一個空節點,node便能符合
//STL對於“前閉後開”區間的要求,成爲last迭代器。這樣的話,
//begin(),end(),empty(),size(),front(),back()等函數都能輕易完成 
iterator end() { return node; } //鏈表爲環,所以頭節點就是end 
const_iterator end() const { return node; } 
reverse_iterator rbegin() { return reverse_iterator(end()); } 
const_reverse_iterator rbegin() const { 
    return const_reverse_iterator(end()); 
} 
reverse_iterator rend() { return reverse_iterator(begin()); } 
const_reverse_iterator rend() const { 
    return const_reverse_iterator(begin()); 
} 

// 頭結點指向自身說明鏈表中無元素 
bool empty() const { return node->next == node; } 

// 使用全局函數distance()進行計算, 時間複雜度O(n) 
size_type size() const { 
    size_type result = 0; 
    distance(begin(), end(), result); 
    return result; 
} 
size_type max_size() const {    return size_type(-1); } 
reference front() { return *begin(); } 
const_reference front() const { return *begin(); } 
//end指向的是一個空白節點,所以要先自減再求值 
reference back() { return *(--end()); } 
const_reference back() const { return *(--end()); } 
void swap(list<T, Alloc>& x) { __STD::swap(node, x.node); 

//在迭代器position位置插入一個節點,內容爲x 
iterator insert(iterator position, const T& x) 
{ 
    link_type tmp = create_node(x); //產生節點,內容爲x 
    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()); }
#ifdef __STL_MEMBER_TEMPLATES 
template <class InputIterator> 
void insert(iterator position, InputIterator first, InputIterator last);
#else /* __STL_MEMBER_TEMPLATES */ 
void insert(iterator position, const T* first, const T* last); 
void insert(iterator position, const_iterator first, const_iterator last);
#endif /* __STL_MEMBER_TEMPLATES */ 

// 指定位置插入n個值爲x的元素, 詳細解析見實現部分 
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() 
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_node; 
    destroy_node(position.node); 
    return iterator(next_node); 
} 
// 擦除一個區間的結點, 詳細解析見實現部分 
iterator erase(iterator first, iterator last); 
void resize(size_type new_size, const T& x);
void resize(size_type new_size) { resize(new_size, T()); } 
void clear(); 

// 刪除鏈表第一個結點 
void pop_front() { erase(begin()); } 

// 刪除鏈表最後一個結點 
void pop_back() { 
    iterator tmp = end(); 
    erase(--tmp); 
} 

list(size_type n, const T& value) { fill_initialize(n, value); } 
list(int n, const T& value) { fill_initialize(n, value); } 
list(long n, const T& value) { fill_initialize(n, value); } 
explicit list(size_type n) { fill_initialize(n, T()); }

// 以一個區間元素爲藍本創建鏈表
#ifdef __STL_MEMBER_TEMPLATES 
template <class InputIterator> 
list(InputIterator first, InputIterator last) 
{ 
    range_initialize(first, last); 
}#else /* __STL_MEMBER_TEMPLATES */ 
    list(const T* first, const T* last) { range_initialize(first, last); } 
    list(const_iterator first, const_iterator last) { 
        range_initialize(first, last); 
    }
#endif /* __STL_MEMBER_TEMPLATES */ 

// 複製構造
    list(const list<T, Alloc>& x) { 
        range_initialize(x.begin(), x.end()); 
    } 

    ~list() 
    { 
        // 釋放所有結點 
        // 使用全局函數distance()進行計算, 時間複雜度O(n) 
        size_type size() const { 
            size_type result = 0;
            distance(begin(), end(), result); 
            return result; 
        } 
        clear(); 
        // 釋放頭結點 
        put_node(node); 
    } 
    list<T, Alloc>& operator=(const list<T, Alloc>& x);
protected:

// 將[first, last)區間插入到position
// 如果last == position, 則相當於鏈表不變化, 不進行操作
//list內部提供所謂的遷移操作(transfer):將某連續範圍內元素遷移到某個特定位置
//之前。技術上很簡單,節點間指針移動而已。該操作爲其它複雜操作如splic、sort
//以及merge等奠定了良好的基礎
//該函數將[first,last)內所有元素移動到position之前
//該函數接收的[last,last)區間可以在同一list中,也可以不再同一list內。
//但是,position不能位於[first, last)
//代碼下方有該函數的圖示
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; } }
public: 
    // 將鏈表x移動到position之前 
    void splice(iterator position, list& x) { 
        if (!x.empty()) 
            transfer(position, x.begin(), x.end()); 
    } 

    // 將鏈表中i指向的內容移動到position之前 
    void splice(iterator position, list&, iterator i) { 
        iterator j = i; 
        ++j; 
        if (position == i || position == j) 
            return; 
        transfer(position, i, j); 
    } 

    // 將[first, last}元素移動到position之前 
    void splice(iterator position, list&, iterator first, iterator last) { 
        if (first != last) transfer(position, first, last); 
    } 
    void remove(const T& value); 
    void unique(); 
    void merge(list& x); 
    void reverse(); 
    void sort();
#ifdef __STL_MEMBER_TEMPLATES template <class Predicate> 
    void remove_if(Predicate); 
    template <class BinaryPredicate> void unique(BinaryPredicate); 
    template <class StrictWeakOrdering> void merge(list&, StrictWeakOrdering);
    template <class StrictWeakOrdering> void sort(StrictWeakOrdering);
#endif     /* __STL_MEMBER_TEMPLATES */ 

    friend bool operator== __STL_NULL_TMPL_ARGS (const list& x, const list& y);
};

// 判斷兩個鏈表是否相等
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; 
    return n1 == e1 && n2 == e2;
}

// 鏈表比較大小使用的是字典順序
template <class T, class Alloc>
inline bool operator<(const list<T, Alloc>& x, const list<T, Alloc>& y)
{ 
    return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
}
// 如果編譯器支持模板函數特化優先級
// 那麼將全局的swap實現爲使用list私有的swap以提高效率
#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
template <class T, class Alloc>
inline void swap(list<T, Alloc>& x, list<T, Alloc>& y){
    x.swap(y);
}#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
// 將[first, last)區間插入到position之前
#ifdef __STL_MEMBER_TEMPLATES
template <class T, class Alloc> template <class InputIterator>
void list<T, Alloc>::insert(iterator position, 
                             InputIterator first, InputIterator last)
{ 
    for ( ; first != last; ++first) 
        insert(position, *first);
}#else  /* __STL_MEMBER_TEMPLATES */
template <class T, class Alloc>
void list<T, Alloc>::insert(iterator position, const T* first, const T* last) 
{ 
    for ( ; first != last; ++first) 
        insert(position, *first);
}
template <class T, class Alloc>
void list<T, Alloc>::insert(iterator position, 
                          const_iterator first, const_iterator last) 
{ 
    for ( ; first != last; ++first) 
        insert(position, *first);
}
#endif /* __STL_MEMBER_TEMPLATES */
// 在position前插入n個值爲x的元素
template <class T, class Alloc>
void list<T, Alloc>::insert(iterator position, size_type n, const T& x)
{ 
    for ( ; n > 0; --n) 
        insert(position, x);
}

// 擦除[first, last)間的結點
template <class T, class Alloc>
list<T,Alloc>::iterator list<T, Alloc>::erase(iterator first, iterator last)
{ 
    while (first != last) 
        erase(first++); return last;
}

// 重新設置容量大小
// 如果當前容量小於新容量, 則新增加值爲x的元素, 使容量增加至新指定大小
// 如果當前容量大於新容量, 則析構出來的元素
template <class T, class Alloc>
void list<T, Alloc>::resize(size_type new_size, const T& x)
{
    iterator i = begin(); 
    size_type len = 0; 
    for ( ; i != end() && len < new_size; ++i, ++len) 
        ; 
    if (len == new_size) 
        erase(i, end()); 
    else // i == end() 
        insert(end(), new_size - len, x);}

// 銷燬所有結點, 將鏈表置空
template <class T, class Alloc>
void list<T, Alloc>::clear()
{ 
    link_type cur = (link_type) node->next;
    while (cur != node) {     //遍歷每個節點 
        link_type tmp = cur; 
        cur = (link_type) cur->next; 
        destroy_node(tmp); //銷燬(析構並釋放) 
    }
    //恢復node初始狀態
    node->next = node; 
    node->prev = node;
}

// 鏈表賦值操作
// 如果當前容器元素少於x容器, 則析構多餘元素,
// 否則將調用insert插入x中剩餘的元素
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++; 
        if (first2 == last2) 
            erase(first1, last1); 
        else insert(last1, first2, last2); 
    }
    return *this;
}

// 移除特定值的所有結點
// 時間複雜度O(n)
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;
    }
}

// 移除容器內所有的相鄰的重複結點,“連續且相同”的元素才移除
// 時間複雜度O(n)
// 用戶自定義數據類型需要提供operator ==()重載
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; 
    }
}

// 假設當前容器和x都已序, 保證兩容器合併後仍然有序
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) 
        if (*first2 < *first1) { 
            iterator next = first2; 
            transfer(first1, first2, ++next); 
            first2 = next;
        }
        else 
            ++first1; 
    if (first2 != last2) 
        transfer(last1, first2, last2);}
// 將鏈表倒置
// 其算法核心是歷遍鏈表, 每次取出一個結點, 並插入到鏈表起始點
// 歷遍完成後鏈表滿足倒置
template <class T, class Alloc>
void list<T, Alloc>::reverse()
{ 
    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);
    }
}

// 按照升序排序
template <class T, class Alloc>
void list<T, Alloc>::sort()
{ 
    if (node->next == node || link_type(node->next)->next == node) return; 
    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]);
}

#ifdef __STL_MEMBER_TEMPLATES

// 給定一個仿函數, 如果仿函數值爲真則進行相應元素的移除
template <class T, class Alloc> 
template <class Predicate>void list<T, Alloc>::remove_if(Predicate pred)
{ 
    iterator first = begin(); 
    iterator last = end();
    while (first != last) { 
        iterator next = first; 
        ++next; 
        if (pred(*first))
            erase(first); 
        first = next; 
    }
}

// 根據仿函數, 決定如何移除相鄰的重複結點
template <class T, class Alloc> 
template <class BinaryPredicate>
void list<T, Alloc>::unique(BinaryPredicate binary_pred){ 
    iterator first = begin(); 
    iterator last = end(); 
    if (first == last) return;
    iterator next = first; 
    while (++next != last) { 
        if (binary_pred(*first, *next)) 
            erase(next); 
        else 
            first = next; 
        next = first; 
    }
}

// 假設當前容器和x均已序, 將x合併到當前容器中, 並保證在comp仿函數
// 判定下仍然有序
template <class T, class Alloc> template <class StrictWeakOrdering>
void list<T, Alloc>::merge(list<T, Alloc>& x, StrictWeakOrdering comp)
{
    iterator first1 = begin(); 
    iterator last1 = end();
    iterator first2 = x.begin(); 
    iterator last2 = x.end(); 
    while (first1 != last1 && first2 != last2)
        if (comp(*first2, *first1)) { 
            iterator next = first2;
            transfer(first1, first2, ++next); 
            first2 = next; } 
        else 
            ++first1; 
    if (first2 != last2) 
        transfer(last1, first2, last2);
}

// 根據仿函數comp據定如何排序
template <class T, class Alloc> template <class StrictWeakOrdering>
void list<T, Alloc>::sort(StrictWeakOrdering comp)
{ 
    if (node->next == node || link_type(node->next)->next == node) 
        return; 
    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, comp); 
            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], comp);
    swap(counter[fill-1]);
}
#endif /* __STL_MEMBER_TEMPLATES */

#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma reset woff 1174
#endif__STL_END_NAMESPACE
#endif /* __SGI_STL_INTERNAL_LIST_H */
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章