#include <iostream> using namespace std; //採用迭代器和空间配置器所实现的双向链表的基本功能 template<class _Ty,class _A = allocator<_Ty> > //定义模板类 class list //list类 { public: typedef size_t size_type; //类型重定义 protected: struct _Node; //结构体_Node friend struct _Node; //友元 typedef _Node* _Nodeptr; //类型重定义 struct _Node //结构体定义 { _Nodeptr _Next,_Prev; _Ty _Value; }; protected: _A allocator; _Nodeptr _Head; size_type _Size; public: typedef list<_Ty,_A> _Myt; typedef _A allocator_type; //该类型是模板參数A的同义词 typedef size_t size_type; //正整数类型 typedef ptrdiff_t difference_type; //整数类型 typedef _Ty* pointer; //指向_Ty的指针 typedef const _Ty* const_pointer; //指向_Ty的常量指针 typedef _Ty& reference; //_Ty的引用 typedef const _Ty& const_reference; //_Ty的常量引用 typedef _Ty value_type; //对象类型_Ty class iterator; //訪问list的迭代器 class const_iterator; //訪问list的常量迭代器 friend class const_iterator; //友元 class const_iterator : public _Bidit<_Ty, difference_type> //继承 { public: //共同拥有成员 _Nodeptr _Mynode() const //指向当前结点 { return (_Ptr); } const_iterator() //默认构造函数 {} const_iterator(_Nodeptr _P):_Ptr(_P) //參数为指针的构造函数 {} const_iterator(const iterator& _X):_Ptr(_X._Ptr) //參数为訪问list的常量迭代器的构造函数 {} const_reference operator*() const //获取当前_Ty的常量的值 { return _Ptr->_Value; } const_pointer operator->() const //? { return (&**this); } const_iterator& operator++() //前置++的引用 { _Ptr = _Ptr->_Next; return (*this); } const_iterator operator++(int) //后置++的引用 { const_iterator _Tmp = *this; ++*this; return (_Tmp); } const_iterator& operator--() //前置--的引用 { _Ptr = _Ptr->_Prev; return (*this); } const_iterator operator--(int) //后置--的引用 { const_iterator _Tmp = *this; --*this; return (_Tmp); } bool operator==(const const_iterator& _X) const //推断是否相等 { return (_Ptr == _X._Ptr); } bool operator!=(const const_iterator& _X) const //推断是否不等 { return (!(*this == _X)); } protected: //保护成员 _Nodeptr _Ptr; }; friend class iterator; //友元 class iterator : public const_iterator //继承 { public: iterator() //默认构造函数 {} iterator(_Nodeptr _P): const_iterator(_P) //參数为指针的构造函数 {} reference operator*() const //获取当前_Ty的值 { return _Ptr->_Value; } _Ty* operator->() const //? { return (&**this); } iterator& operator++() //前置++的引用 { _Ptr = _Ptr->_Next; return (*this); } iterator operator++(int) //后置++的引用 { iterator _Tmp = *this; ++*this; return (_Tmp); } iterator& operator--() //前置--的引用 { _Ptr = _Ptr->_Prev; return (*this); } iterator operator--(int) //后置--的引用 { iterator _Tmp = *this; --*this; return (_Tmp); } bool operator==(const iterator& _X) const //推断是否相等 { return (_Ptr == _X._Ptr); } bool operator!=(const iterator& _X) const //推断是否不等 { return (!(*this == _X)); } }; public: _Nodeptr _Buynode(_Nodeptr _Narg = 0, _Nodeptr _Parg = 0) //购买结点 { _Nodeptr _S = (_Nodeptr)allocator._Charalloc( //开辟空间 1 * sizeof (_Node)); _S->_Next = _Narg != 0 ? _Narg : _S;; _S->_Prev = _Parg != 0 ? _Parg : _S; return (_S); } void _Freenode(_Nodeptr _S) //释放空间 { allocator.deallocate(_S, 1); } void _Splice(iterator _P, _Myt& _X, iterator _F, iterator _L) //拼接 { if (allocator == _X.allocator) //将两个拼接到一起,_X清空 { (_L._Mynode())->_Prev->_Next = _P._Mynode(); (_F._Mynode())->_Prev->_Next = _L._Mynode(); (_P._Mynode())->_Prev->_Next = _F._Mynode(); _Nodeptr _S = (_P._Mynode())->_Prev; (_P._Mynode())->_Prev =(_L._Mynode())->_Prev; (_L._Mynode())->_Prev =(_F._Mynode())->_Prev; (_F._Mynode())->_Prev = _S; } else //将_X中的链表数值加入到_P中,_X清空 { insert(_P, _F, _L); _X.erase(_F, _L); } } void _Xran() const //抛出异常 { _THROW(out_of_range, "invalid list<T> subscript"); } public: size_type size() const //长度 { return (_Size); } bool empty() const //判空 { return (size() == 0); } _A get_allocator() const //返回空间配置器 { return (allocator); } void resize(size_type _N, _Ty _X = _Ty()) //又一次定义链表长度 { if (size() < _N) { insert(end(), _N - size(), _X); } else { while (_N < size()) { pop_back(); } } } size_type max_size() const //返回链表最大可能长度 { return (allocator.max_size()); } reference front() //返回第一个元素的引用 { return (*begin()); } const_reference front() const //返回第一个元素的常量引用 { return (*begin()); } reference back() //返回最后一元素的引用 { return (*(--end())); } const_reference back() const //返回最后一元素的常量引用 { return (*(--end())); } _Myt& operator=(const _Myt& _X) //运算符构造函数 { if (this != &_X) { iterator _F1 = begin(); iterator _L1 = end(); const_iterator _F2 = _X.begin(); const_iterator _L2 = _X.end(); for (; _F1 != _L1 && _F2 != _L2; ++_F1, ++_F2) { *_F1 = *_F2; } erase(_F1, _L1); insert(_L1, _F2, _L2); } return (*this); } public: explicit list():_Head(_Buynode()), _Size(0) //空链表 {} explicit list(const _Ty& _V):_Head(_Buynode()), _Size(0) //建一个含_V个默认值是0的元素的链表 { insert(begin(),_V,0); } explicit list(size_type _N, const _Ty& _V):_Head(_Buynode()), _Size(0) //建一个含_V个元素的链表。值都是_N { insert(begin(),_N, _V); } list(const _Myt& _X): _Head(_Buynode()), _Size(0) //建一个_X的copy链表 { insert(begin(), _X.begin(), _X.end()); } list(const _Ty *_F, const _Ty *_L): _Head(_Buynode()), _Size(0) //一个区域的元素[_First, _Last)。 { insert(begin(), _F, _L); } typedef const_iterator _It; list(_It _F, _It _L):_Head(_Buynode()), _Size(0) //常量迭代器 { insert(begin(), _F, _L); } iterator begin() //迭代器第一个节点 { return iterator(_Head->_Next); } const_iterator begin() const //常量迭代器第一个节点 { return (const_iterator(_Head->_Next)); } iterator end() //返回最后一个元素的下一位置的指针 { return iterator(_Head); } const_iterator end() const //返回最后一个元素的下一位置的指针 { return (const_iterator(_Head)); } iterator insert(iterator _P,const _Ty& _X) //在_P之前插入结点 { _Nodeptr _S = _P._Mynode(); _S->_Prev = _Buynode(_S,_S->_Prev); _S = _S->_Prev; _S->_Prev->_Next = _S; _S->_Value = _X; ++_Size; return (iterator(_S)); } void insert(iterator _P,size_type _M, const _Ty& _X) //在_P之前插入_M个_X结点 { for(;0 < _M;--_M) { insert(_P,_X); } } void insert(iterator _P, const _Ty *_F, const _Ty *_L) //在_P之前插入_F到_L的结点 { for (; _F != _L; ++_F) { insert(_P, *_F); } } typedef const_iterator _It; void insert(iterator _P, _It _F, _It _L) //在_P之前插入迭代器_F到_L的结点 { for (; _F != _L; ++_F) { insert(_P, *_F); } } void push_front(const _Ty& _X) //添加一元素到链表头 { insert(begin(), _X); } void pop_front() //删除链表头的一元素 { erase(begin()); } void push_back(const _Ty& _X) //添加一元素到链表尾 { insert(end(), _X); } void pop_back() //删除链表尾的一个元素 { erase(--end()); } void assign(size_type _N, const _Ty& _X) //分配值 { erase(begin(),end()); insert(begin(),_N, _X); } iterator erase(iterator _P) //删除_P元素 { _Nodeptr _S = (_P++)._Mynode(); _S->_Prev->_Next = _S->_Next; _S->_Next->_Prev = _S->_Prev; _Freenode(_S); --_Size; return (_P); } iterator erase(iterator _F, iterator _L) //删除_F到_L区域的元素 { while (_F != _L) { erase(_F++); } return (_F); } void clear() //删除全部元素 { erase(begin(),end()); } void show() //STL源代码中不存在的函数,自己加的,为了使得測试更方便 { _Nodeptr _P = _Head->_Next; while(_P != _Head) { cout<<_P->_Value<<"-->"; _P = _P->_Next; } cout<<"Over"<<endl; } ~list() //析构函数 { erase(begin(),end()); _Freenode(_Head); _Head = 0, _Size = 0; } public: void swap(_Myt& _X) //交换两个链表 { if (allocator == _X.allocator) //若空间配置器同样,则仅仅需交换头结点和大小 { std::swap(_Head, _X._Head); std::swap(_Size, _X._Size); } else //否则将链表分别拼接到对方空间中 { iterator _P = begin(); splice(_P, _X); _X.splice(_X.begin(), *this, _P, end()); } } friend void swap(_Myt& _X, _Myt& _Y) //交换两个链表 { _X.swap(_Y); } void splice(iterator _P, _Myt& _X) //对两个链表进行拼接 { if (!_X.empty()) { _Splice(_P, _X, _X.begin(), _X.end()); _Size += _X._Size; _X._Size = 0; } } void splice(iterator _P, _Myt& _X, iterator _F) //对两个链表进行拼接 { iterator _L = _F; if (_P != _F && _P != ++_L) { _Splice(_P, _X, _F, _L); ++_Size; --_X._Size; } } void splice(iterator _P, _Myt& _X, iterator _F, iterator _L) //对两个链表进行拼接 { if (_F != _L) { if (&_X != this) { difference_type _N = 0; _Distance(_F, _L, _N); _Size += _N; _X._Size -= _N; } _Splice(_P, _X, _F, _L); } } void remove(const _Ty& _V) //从链表中删除全部值为_V的元素 { iterator _L = end(); for (iterator _F = begin(); _F != _L; ) { if (*_F == _V) { erase(_F++); } else { ++_F; } } } void unique() //删除全部反复的元素,以建立一个具有唯一元素值的链表, //即链表中不会有反复元素 { iterator _F = begin(), _L = end(); if (_F != _L) { for (iterator _M = _F; ++_M != _L; _M = _F) { if (*_F == *_M) { erase(_M); } else { _F = _M; } } } } void merge(_Myt& _X) //把当前链表*this和x合并,合并后x为空。 //把x中的元素插入到当前链表中。不同意两个链表同样 { if (&_X != this) { iterator _F1 = begin(), _L1 = end(); iterator _F2 = _X.begin(), _L2 = _X.end(); while (_F1 != _L1 && _F2 != _L2) { if (*_F2 < *_F1) { iterator _Mid2 = _F2; _Splice(_F1, _X, _F2, ++_Mid2); _F2 = _Mid2; } else { ++_F1; } } if (_F2 != _L2) { _Splice(_L1, _X, _F2, _L2); } _Size += _X._Size; _X._Size = 0; } } void reverse() //反转链表中的元素排序 { if (2 <= size()) { iterator _L = end(); for (iterator _F = ++begin(); _F != _L; ) { iterator _M = _F; _Splice(begin(), *this, _M, ++_F); } } } void sort() //依据默认条件对链表进行排序? { if (2 <= size()) { const size_t _MAXN = 15; _Myt _X, _A[_MAXN + 1]; size_t _N = 0; while (!empty()) { _X.splice(_X.begin(), *this, begin()); size_t _I; for (_I = 0; _I < _N && !_A[_I].empty(); ++_I) { _A[_I].merge(_X); _A[_I].swap(_X); } if (_I == _MAXN) { _A[_I].merge(_X); } else { _A[_I].swap(_X); if (_I == _N) { ++_N; } } } while (0 < _N) { merge(_A[--_N]); } } } }; template<class _Ty, class _A> inline //模板类推断是否相等 bool operator==(const list<_Ty, _A>& _X, const list<_Ty, _A>& _Y) { return (_X.size() == _Y.size() && equal(_X.begin(), _X.end(), _Y.begin())); } template<class _Ty, class _A> inline //模板类推断是否不等 bool operator!=(const list<_Ty, _A>& _X, const list<_Ty, _A>& _Y) { return (!(_X == _Y)); } template<class _Ty, class _A> inline //模板类比較链表的大小 bool operator<(const list<_Ty, _A>& _X, const list<_Ty, _A>& _Y) { return (lexicographical_compare(_X.begin(), _X.end(), _Y.begin(), _Y.end())); } template<class _Ty, class _A> inline //模板类比較链表的大小_Y < _X bool operator>(const list<_Ty, _A>& _X, const list<_Ty, _A>& _Y) { return (_Y < _X); } template<class _Ty, class _A> inline //模板类比較链表的大小!(_Y < _X) bool operator<=(const list<_Ty, _A>& _X, const list<_Ty, _A>& _Y) { return (!(_Y < _X)); } template<class _Ty, class _A> inline //模板类比較链表的大小!(_X < _Y) bool operator>=(const list<_Ty, _A>& _X, const list<_Ty, _A>& _Y) { return (!(_X < _Y)); } void main() { list<int> c0; //空链表 list<int> c1(3); //建一个含三个默认值是0的元素的链表 list<int> c2(c1); //建一个c1的copy链表 list<int> c3(c1.begin(),c1.end()); //含c1一个区域的元素[_First, _Last)。 int ar[5] = {2,3,4,5,6}; list<int> itlist(ar,ar+5); //用数组赋值 list<int> mylist(3,2); //建一个含三个元素的链表,值都是2 mylist.show(); list<int> youlist(3,3); youlist.show(); swap(mylist, youlist); //交换两个链表 mylist.show(); youlist.show(); mylist.swap(youlist); mylist.show(); youlist.show(); list<int>::iterator i1 = itlist.begin(); itlist.splice(i1,mylist); //对两个链表进行结合 itlist.show(); itlist.remove(3); itlist.show(); itlist.unique(); itlist.show(); itlist.merge(mylist); itlist.show(); mylist.show(); itlist.reverse(); itlist.show(); itlist.sort(); itlist.show(); cout<<operator<(itlist,mylist)<<endl; cout<<operator>(itlist,mylist)<<endl; }
原文:http://www.cnblogs.com/gccbuaa/p/7215796.html