list
本质是一个带有头结点的双向循环链表
头结点的下一个节点是第一个节点,头结点是尾节点
代码
#include <iostream>
using namespace std;
namespace bite
{
// List的节点类
template<class T>
struct ListNode
{
ListNode(const T& val = T())
:_pPre(nullptr)
, _pNext(nullptr)
, _val(val)
{}//ListNode构造函数
ListNode<T>* _pPre;
ListNode<T>* _pNext;
T _val;//类成员,前驱节点,后继节点和val值
};
template<class T>
class list;
//List的迭代器类
template<class T, class Ref, class Ptr>
class ListIterator
{
friend class list < T > ;
typedef ListNode<T>* PNode;
typedef ListIterator<T, Ref, Ptr> Self;
public:
ListIterator(PNode pNode = nullptr)
:_pNode(pNode)
{}//迭代器的构造函数
ListIterator(const Self& l)
:_pNode(l._pNode)
{}//迭代器的拷贝构造函数
T& operator*()
{
return _pNode->_val;
}//重载迭代器的解引用
T* operator->()
{
return &(operator*());
}//重载->,访问其所指空间成员
Self& operator++()
{
_pNode = _pNode->_pNext;
return *this;
}//重载前++
Self operator++(int)
{
Self temp(*this);
_pNode = _pNode->_pNext;
return temp;
}//重载后++
Self& operator--()
{
_pNode = _pNode->_pPre;
return *this;
}//重载前--
Self operator--(int)
{
Self temp(*this);
_pNode = _pNode-> + pPre;
return temp;
}//重载后--
bool operator!=(const Self& l)
{
return _pNode != l._pNode;
}//重载!=
bool operator==(const Self& l)
{
return _pNode == l._pNode;
}//重载==
private:
PNode _pNode;//迭代器内部其实是一个指针,迭代器通过对这个指针的操作,来实现各种功能
//这里解释一下为什么要有迭代器?
//迭代器一般有两种实现方式,具体根据容器底层数据结构实现:
//1.原生态指针,比如:vector
//2.将原生态指针进行封装,在自定义的类中实现指针的功能,类似解引用,->,++,--,比较等。
//比如:list这里就是将原生态指针进行了封装,因为单纯的指针没有办法实现链表的功能。
//因为链表的++时指向下一个节点,而指针的++则是单纯的++,并不能指向链表的下一个节点。
//注意:这里比较难理解,可以多看几遍。
};
//list类
template<class T>
class list
{
typedef ListNode<T> Node;
typedef Node* PNode;
public:
typedef ListIterator<T, T&, T*> iterator;
typedef ListIterator<T, const T&, const T&> const_iterator;
public:
///
// List的构造
list()
{
CreateHead();
}
list(int n, const T& value = T())
{
CreateHead();
for (int i = 0 ; i < n; i++)
push_back(value);
}
template <class Iterator>
list(Iterator first, Iterator last)
{
CreateHead();
while (first != last)
{
push_back(*first);
++first;
}
}
//拷贝构造函数
list(const list<T>& l)
{
CreateHead();
list<T> temp(l.begin(), l.end());
this->swap(temp);
}
//赋值构造函数
list<T>& operator=(list<T> l)
{
this->swap(l);
return *this;
}
//赋值构造函数
~list()
{
clear();
delete _pHead;
_pHead = nullptr;
}
///
// List Iterator
iterator begin(){ return iterator(_pHead->_pNext); }
//返回第一个节点,也就是头结点的next
iterator end(){ return iterator(_pHead); }
//返回尾结点,即头结点
const_iterator begin()const{return const_iterator(_pHead->_pNext);}
const_iterator end()const{ return const_iterator(_pHead); }
///
// List Capacity
//计算节点个数
size_t size()const
{
iterator first=iterator(begin());
iterator last = iterator(end());
int count = 0;
while (first != last)
{
count++;
first++;
}
return count;
}
//判空
bool empty()const{ return size() == 0; }
// List Access
//返回第一个节点的值
T& front(){ return *begin(); }
const T& front()const{ return *begin();}
//返回最后一个节点的值
T& back(){ return *--end(); }
const T& back()const{ return *--end(); }
// List Modify
//尾插、尾删、头插、头删
void push_back(const T& val){ insert(end(), val); }
void pop_back(){ erase(--end()); }
void push_front(const T& val){ insert(begin(), val); }
void pop_front(){ erase(begin()); }
// 在pos位置前插入值为val的节点,返回插入节点的指针
iterator insert(iterator pos, const T& val)
{
PNode _S = new Node(val);
PNode cur = pos._pNode;
_S->_pPre = cur->_pPre;
_S->_pNext = cur;
_S->_pPre->_pNext = _S;
cur->_pPre = _S;
return iterator(_S);
}
// 删除pos位置的节点,返回该节点的下一个位置
iterator erase(iterator pos)
{
PNode pDel = pos._pNode;
PNode pRet = pDel->_pNext;
pDel->_pNext->_pPre = pDel->_pPre;
pDel->_pPre->_pNext = pRet;
delete pDel;
return iterator(pRet);
}
//按照数组来清除
iterator erase(iterator _first, iterator _last)
{
while (_first != _last)
{
_first = erase(_first);
}
return iterator(_last);
}
//清空链表
void clear()
{
erase(begin(), end());
}
//交换函数
void swap(list<T>& l)
{
PNode tmp = new Node;
tmp = _pHead;
_pHead = l._pHead;
l._pHead = tmp;
}
private:
//生成头结点
void CreateHead()
{
_pHead = new Node;
_pHead->_pNext = _pHead;
_pHead->_pPre = _pHead;
}
//类成员,是一个头结点
PNode _pHead;
};
};
void main()
{
bite::list<int> l1;
bite::list<int> l2(10, 5);
l2.push_back(2);
l2.pop_back();
int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
bite::list<int> l3(arr, arr + 10);
auto pos = l3.begin();
l3.insert(pos, 0);
++pos;
l3.insert(pos, 100);
l3.erase(l3.begin());
l3.erase(pos);
bite::list<int> l4(l3);
l1 = l4;
l3.push_front(0);
l3.pop_front();
for (auto &e : l3)
cout << e << " ";
cout << endl;
}