#include<iostream>
using namespace std;
namespace bit
{
template<typename T>
struct ListNode
{
T val;
struct ListNode* pre;
struct ListNode* next;
ListNode(const T& x = T())
:pre(nullptr), next(nullptr), val(x)
{}
};
template<class T,class Ref,class Ptr>
struct IteratorNode
{
typedef ListNode<T> node;
typedef IteratorNode<T, Ref, Ptr> self;//T T& T*
node* _node;
IteratorNode(node* n)
:_node(n)
{}
//*T
T operator*()
{
return _node->val;
}
//T->
Ptr operator->()
{
return &_node->val;
}
//T++;
self& operator++()
{
_node = _node->next;
return *this;
}
//++T
self operator++(int)
{
IteratorNode tmp(*this);
_node = _node->next;
return tmp;
}
//--T
self& operator--()
{
_node = _node->_prev;
return *this;
}
//T--
self operator--(int)
{
self tmp(*this);
_node = _node->_prev;
return tmp;
}
bool operator!=(const self& it)
{
return _node != it._node;
}
bool operator==(const self& it)
{
return _node == it._node;
}
};
template<typename T>
struct list
{
typedef ListNode<T> node;
typedef IteratorNode<T,T*,T&> iterator;
typedef IteratorNode<T,const T*,const T&> const_iterator;
private:
node* head;
size_t size;
public:
void init()
{
head = new node;
head->next = head;
head->pre = head;
size = 0;
}
list()
{
init();
}
list(const list<T>& lt)
{
init();
iterator t = lt.head->next;
while (t != lt.head)
{
push_back(t._node->val);
t._node = t._node->next;
}
}
iterator begin()
{
return head->next;
}
iterator end()
{
return head;
}
const_iterator cbegin() const
{
return head->next;
}
const_iterator cend() const
{
return head;
}
void push_back(const T& val)
{
insert(end(), val);
}
void push_front(const T& x)
{
insert(begin(), x);
}
void pop_front()
{
erase(begin());
}
void pop_back()
{
erase(end()->pre);
}
void insert(iterator pos, const T& val)
{
node* newn = new node;
newn->val = val;
newn->pre = pos._node->pre;
pos._node->pre->next = newn;
newn->next = pos._node;
pos._node->pre = newn;
size++;
}
iterator erase(iterator t)
{
iterator pos = t._node->next;
t._node->pre->next = t._node->next;
t._node->next->pre = t._node->pre;
delete []t._node;
size--;
return pos;
}
void clear()
{
iterator t = begin();
while (t != end())
{
t=erase(t);
}
}
void swap(list<T>& lt)
{
std::swap(head, lt.head);
std::swap(size, lt.size);
}
list<T>& operator=(list<T> lt)
{
swap(lt);
return *this;
}
~list()
{
clear();
delete[] head;
head = nullptr;
}
size_t _size() const
{
return size;
}
bool empty()
{
return size == 0;
}
};
}
list模拟实现
最新推荐文章于 2024-07-23 21:10:46 发布