#include <iostream>
#include <iterator>
#include <memory>
#include <algorithm>
using namespace std;
template <typename T> // 結點結構
struct __list_node
{
typedef void* void_pointer;
void_pointer prev;
void_pointer next;
T data;
};
template <typename T, typename Ref = T&, typename Ptr = T*> //迭代器
struct __list_iterator
{
typedef __list_iterator<T, T&, T*> iterator;
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;
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_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;
}
reference operator*() const // 重載解引用運算符
{
return (*node).data;
}
reference operator->() const // 重載箭頭運算符
{
return &(operator*());
}
self& operator++() // 前增版本
{
node = (link_type)((*node).next);
return *this;
}
self& operator++(int) // 後增版本
{
self tmp = *this;
++*this;
return *this;
}
self& operator--()
{
node = (link_type)((*node).prev);
return *this;
}
self& operator--(int)
{
self tmp = *this;
--*this;
return *this;
}
};
template <typename T, typename Alloc = allocator<T>>
class list
{
protected:
typedef void* void_pointer;
typedef __list_node<T> list_node;
//typedef allocator<T> 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> iterator;
typedef __list_iterator<T, const T&, const T*> const_iterator;
typedef reverse_iterator<const_iterator> const_reverse_iterator;
typedef reverse_iterator<iterator> reverse_iterator;
protected:
link_type get_node() { return list_node_allocator.allocate(1); } // 分配一個結點的內存 但不構造
void put_node(link_type p) { list_node_allocator.deallocate(p, 1); } // 釋放指定結點內存 但不析構
link_type creat_node(const T &x) // 創建並構造一個結點
{
link_type p = get_node();
list_node_allocator.construct(&(p->data), x);
return p;
}
void destory_node(link_type p) // 析構並且釋放一個結點
{
list_node_allocator.destory(&(p->data));
put_node(p);
}
protected:
void empty_initialize() //用於空鏈表的建立
{
node = get_node();
node->next = node;
node->prev = node;
}
void fill_initialize(size_type n, const T& value) // 創建n個值爲value的結點的鏈表
{
empty_initialize();
insert(begin(), n, value);
}
template <typename InputIterator>
void range_initialize(InputIterator first, InputIterator last) // 創建一個由區間初始化的鏈表
{
empty_initialize();
insert(begin(), first, last);
}
protected:
link_type node; //指向空白尾後結點
Alloc list_node_allocator; // 管理內存分配回收
public:
list() { empty_initialize(); } // 構造一個空鏈表
list(size_type n, const T &value) { fill_initialize(n, value); } // 以n個相同元素初始化
explicit list(size_type n) { fill_initialize(n, T()); }
template <typename InputIterator> // 以一個區間初始化
list(InputIterator first, InputIterator last)
{
range_initialize(first, last);
}
list(const list<T, Alloc> &x) // 複製構造
{
range_initialize(x.begin(), x.end());
}
list<T, Alloc>& operator=(const list<T, Alloc>& x);
~list() // 析構函數 清空鏈表
{
clear();
put_node(node); // 釋放尾後結點所佔的內存
}
iterator begin() { return (link_type)((*node).next); }
const_iterator begin() const { return (link_type)((*node).next); }
iterator end() { return node; }
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;
}
size_type size() const // 調用全局函數distance() 時間複雜度:O(n)
{
size_type result = distance(begin(), end());
return result;
}
size_type max_size() const { return size_type(-1); }
reference front() { return *begin(); }
const_reference front() const { return *begin(); }
reference back() { return *(--end()); }
const_reference back() const { return *(--end()); }
void swap(list<T, Alloc> &x) // j交換指針
{
std::swap(node, x.node);
}
iterator insert(iterator position, const T &x) // 在指定位置前插入一個元素
{
link_type tmp = creat_node(x);
tmp->next = position.node;
tmp->prev = (position.node)->prev;
(link_type(position.node->prev))->next = tmp;
position.node->prev = tmp;
}
iterator insert(iterator position)
{
return insert(position, T());
}
template <class InputIterator> // 在指定位置前插入一個區間
void insert(iterator position, InputIterator first, InputIterator last);
void insert(iterator pos, size_type n, const T& x); // 在指定位置前插入n個x元素
void push_front(const T &x) { insert(begin(), x); }
void push_back(const T &x) { insert(end(), x); }
iterator erase(iterator position) // 擦除指定結點
{
link_type prev_node = (link_type)((position.node)->prev);
link_type next_node = (link_type)((position.node)->next);
prev_node->next = next_node;
next_node->prev = prev_node;
destory_node(position.node);
return iterator(next_node);
}
iterator erase(iterator first, iterator last); // 擦除一個區間
void pop_front() { erase(begin()); } // 刪除鏈表首元結點
void pop_back() // 刪除鏈表最後一個結點
{
iterator tmp = end();
erase(--tmp);
}
void resize(size_type new_size, const T &x); // 調整鏈表大小
void resize(size_type new_size) { resize(new_size, T()); }
void clear(); // 請空鏈表
protected:
// 將[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;
}
}
public:
void splice(iterator position, list& x) // 將鏈表x移動到pos之前 x不能和*this相同
{
if (!x.empty())
transfer(position, x.begin(), x.end());
}
void splice(iterator position, list&, iterator i) // 將i所指向元素接合於position之前 pos和i可能指向同一個list
{
iterator j = i;
++j;
if (position == i || position == j)
{
return;
}
transfer(position, i, j);
}
// 將[first,last)內的所有元素接合於pos之前, pos可能和[first,last)指向同一個list 但pos不能位於[first,last)內
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();
//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);
};
// 判斷兩個鏈表是否相等
template <typename T, typename 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 = e1->next;
link_type n2 = e2->next;
for (; n1 != e1 && n2 != e2; n1 = (link_type)n1->next, (link_type)n2 = n2->next)
{
if (n1->data != n2->data) return false;
}
return n1 == e1 && n2 == e2;
}
// 字典序比較鏈表大小
template <typename T, typename 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());
}
template <typename T, typename Alloc>
inline void swap(list<T, Alloc> &x, list<T, Alloc> &y)
{
x.swap(y);
}
template <typename T, typename 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) // x的元素少於原list
erase(first1, last1);
else
insert(last1, first2, last2); // x的元素多餘原list
}
return *this;
}
template <typename T, typename Alloc>
template <typename InputIterator>
void list<T, Alloc>::insert(iterator position, InputIterator first, InputIterator last)
{
for (; first != last; ++first)
{
insert(position, *first);
}
}
template <typename T, typename Alloc>
void list<T, Alloc>::insert(iterator posistion, size_type n, const T &x)
{
for (; n > 0; --n)
{
insert(posistion, x);
}
}
template <typename T, typename Alloc>
list<T, Alloc>::iterator list<T, Alloc>::erase(iterator first, iterator last)
{
while (first != last)
{
erase(first++);
return last;
}
}
template <typename T, typename 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
insert(end(), new_size - len, x);
}
template <typename T, typename 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;
destory_node(tmp);
}
node->next = node;
node->prev = node;
}
template <typename T, typename Alloc>
void list<T, Alloc>::remove(const T &value) // 移除特定值的所有結點
{
iterator first = begin();
iterator last = end();
for (first != last)
{
iterator next = first;
++next;
if (*first == value)
erase(first);
first = next;
}
}
template <typename T, typename 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;
}
}
template <typename T, typename Alloc>
void list<T, Alloc>::merge(list<T, Alloc> &x) // 將x合併到*this中去 前提是兩個list分別增序排序過
{
iterator first1 = begin();
iterator last1 = end();
iterator first2 = x.begin();
iterator last2 = x.end();
while (first1 != last1 && first2 != last2)
{
if (*first1 < *first2)
{
iterator next = first2;
transfer(first1, first2, ++next);
first2 = next;
}
else
++first1;
}
if (first2 != last2)
transfer(last1, first2, last2);
}
template <typename T, typename 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);
}
}
// 參考 http://blog.csdn.net/chenhanzhun/article/details/39337331
// 因爲list的迭代器是雙向迭代器 所以不能用全局的sort函數 list內部提供了一個sort成員函數
template <typename T, typename 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]; // 中轉站 其中對於counter[i]裏面最多的存儲數據爲2^(i+1)個節點 若超出則向高位進位即counter[i+1]
while (!empty())
{
carry.splice(carry.begin(), *this, begin());//把當前鏈表的第一個節點放在carry鏈表頭
int i = 0;
while (i < fill && !counter[i].empty())
{
counter[i].merge(carry); // 把鏈表carry合併到counter[i]
carry.swap(counter[i++]);//交換鏈表carry和counter[i]內容
}
carry.swap(counter[i]);//交換鏈表carry和counter[i]內容
if (i == fill) ++fill;
for (int i = 1; i < fill; ++i) counter[i].merge(counter[i - 1]); //把低位不滿足進位的剩餘數據全部有序的合併到上一位
swap(counter[fill - 1]);//最後把已排序好的鏈表內容交換到當前鏈表
}
}
list (仿sgi stl)
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.