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 */