模拟准备
避免和库冲突,自己定义一个命名空间
namespace yx
{template<class T>struct ListNode{ListNode<T>* _next;ListNode<T>* _prev;T _data;};template<class T>class list{typedef ListNode<T> Node;public:private:Node* _head;};}
这里的ListNode类为什么用struct呢?
知识点:
class:如果类里有公有,有私有,建议用
struct:如果一个类,全部成员不做访问限定,全公有,建议用
因为下面的list类是要经常访问ListNode的,所以建议用struct
模拟实现
模板ListNode的构造
封装节点的数据
template<class T>
struct ListNode
{ListNode<T>* _next;ListNode<T>* _prev;T _data;ListNode(const T& data):_next(nullptr), _prev(nullptr),_data(data){}
};
list的构造
void list()
{//哨兵位_head = new Node;_head->next = _head;_head->prev = _head;
}
定义一个哨兵位,自己指向自己。
push_back( )
尾插
void push_back(const T& x)
{Node* newnode = new Node(x);Node* tail == _head->prev;tail->_next = newnode;newnode->_prev - tail;newnode->_next = _head;
}
最后一个节点就是头节点的前一个
如果是一个空链表呢?满足条件么?
是可以的,这时候_head 和 tail都是哨兵位(head)
迭代器
说起迭代器,我们先考虑如何遍历链表吧。
我们是否可以像vector那样呢?
typedef Node* iterator;
当然是不可以的。
vector的空间是连续的,而list的空间不连续,那我们如何获取Node*呢?
定义迭代器类
我们可以定义一个类,把节点_node封装起来,来弥补空间不连续的缺陷,能像vector那样一样来进行访问。
template<class T>
class ListIterator
{typedef ListNode<T> Node;Node* _node;
};
template定义的模板参数只能供当前类或当前函数用
而且我们可以在这个类里重载想要的东西
使用时,我们就可以给每个类规范这个迭代器使用的名字,方便我们使用
typedef ListIterator<T> iterator;
template<class T>
class ListIterator
{typedef ListNode<T> Node;typedef ListIterator<T> self; // 返回自己Node* _node;self& operator++(){_node = _node->_next;return *this;//返回节点自己}T& operator*(){return _node->_data;//返回数据,数据类型为T}bool operator!=(const self& it){return _node != it._node;}};
iterator begin( ) 、 iterator end( )
我们实现了迭代器,我们来实现一下链表的头指针和尾指针吧
在list类里
iterator begin()
{//iterator it(_head->_next);//return it;//我们采用匿名对象return iterator(_head->_next);
}
iterator end()
{return iterator(_head;
}
测试通过
operator->( )
T* operator->()
{return &_node->_data;
}
我们来测试一下下面的代码
struct pos
{int _row;int _col;pos(int row = 0, int col = 0):_row(row), _col(col){}
};void test2()
{list<pos> lt1;lt1.push_back(pos(100, 100));lt1.push_back(pos(200, 100));lt1.push_back(pos(300, 100));list<pos>::iterator it = lt1.begin();while (it != lt1.end()){cout << (*it)._row << ":" << (*it)._col << " ";cout << it->_row << ":" << it->_col << " ";++it;}cout << endl;}
第一种用的是对象.成员
第二种指针->成员
第一种比较好理解,it调用operator*(),返回data数据,也就是pos,然后pos._row,pos._col来访问
第二种比较绕,这里为了可读性,省略可一个->,但如果写两个的话不符合语法,于是
cout << it.operator->()->_row << ":" << it.operator->()->_col << " ";
第一个->是operator重载的,而第二个是原生指针的解引用
const迭代器
不能是普通迭代器前面+const修饰。
如:const iterator const
const迭代器目标本身可以修改,指向的内容不能修改 ,
类似:const T* p
p可以修改,*p不能修改
因为T* 和 T&,这里我们可以写一个和迭代器一样的const迭代器类,但我们也可以类模板,传不同的参数,形成不同的类,让编译器帮我们实现。避免了写连个差不多重复的类,减少代码量
insert( )
//在pos前插入val
iterator insert(iterator pos, const T& val)
{Node* pNewNode = new Node(val);Node* pCur = pos._node;pNewNode->_prev = pCur->_prev;pNewNode->_next = pCur;pNewNode->_prev->_next = pNewNode;pCur->_prev = pNewNode;return iterator(pNewNode);
}
erase( )
//删除pos节点
iterator erase(iterator pos)
{Node* pDel = pos._node;Node* pRet = pDel->_next;pDel->_prev->_next = pDel->_next;pDel->_next->_prev = pDel->_prev;delete pDel;return iterator(pRet);
}
clear()
void clear()
{Node* cur = _head->_next;while (cur != _head){//从头开始删(从左向右)_head->_next = cur->_next;delete cur;cur = _head->_next;}_head->_next = _head->_prev = _head;
}
~list()
~list()
{clear();delete _head;_head = nullptr;
}