-----------"别问可不可以,只说愿不愿意"
(1)list是什么?
1.list可以在常数范围内,对任意位置进行插入、删除数据。
2.list底层是双向循环链表。
3.list相对于(vector\string)插入数据,简单高效
4.但list不支持随机访问。
(2)list功能及其使用:
①构造函数
构造函数
| 说明 |
list()
|
构造空的
list
|
list (size_type n, const value_type& val = value_type())
|
构造的
list
中包含
n
个值为
val
的元素
|
list (const list& x)
|
拷贝构造函数
|
list (InputIterator fifirst, InputIterator last)
|
用
[fifirst, last)
区间中的元素构造
list
|
② 迭代器
迭代器
|
说明
|
begin+end
|
返回第一个元素的迭代器
+
返回最后一个元素下一个位置的迭代器
|
rbegin +
rend
|
返回第一个元素的
reverse_iterator,
即
end
位置
,返回最后一个元素下一个位置的reverse_iterator,
即
begin
位置
|
③修改:
函数声明
| 说明 |
push_front
|
在
list
首元素前插入值为
val
的元素
|
pop_front
|
删除
list
中第一个元素
|
push_back
|
在
list
尾部插入值为
val
的元素
|
pop_back
|
删除
list
中最后一个元素
|
insert
|
在
list position
位置中插入值为
val
的元素
|
erase
|
删除
list position
位置的元素
|
swap
|
交换两个
list
中的元素
|
clear
|
清空
list
中的有效元素
|
大部分功能已经介绍了,也就在此打住吧。
(3)list模拟实现:
list基本框架:
①<重>list迭代器:
//迭代器
template<class T>
struct _list_iterator
{
//再让节点在这个 结构体内重命名
typedef _list_node<T> node;
//牵涉一些运算
typedef _list_iterator<T> self;
node* _pnode; //list迭代器 本质就是个 节点指针
_list_iterator(const node* pnode)
:_pnode(pnode)
{}
//*
T& operator* ()
{
return _pnode->_val;
}
//重载!=
bool operator!=(const self& s)
{
//两个地址不一样
return _pnode != s._pnode;
}
//前置++
self& operator++()
{
_pnode = _pnode->_next;
return *this;
}
//后置++
self operator++(int)
{
node* tmp = _pnode;
_pnode = _pnode->_next;
return tmp;
}
//前置--
self& operator--()
{
_pnode = _pnode->_prev;
return *this;
}
//后置
self operator--()
{
node* tmp = _pnode;
_pnode = _pnode->_prev;
return tmp;
}
};
对list迭代器的铺设框架完善好了,简单地进行插入下。
我们先尾插几个数字;
迭代器也可以正常使用。
迭代器模板!!!:
void PrintList(const list<int>& lt)
{
list<int> ::iterator it = lt.begin();
while (it != lt.end())
{
*it += 1;
cout << *it << " ";
++it;
}
cout << endl;
}
此时我们封装一个打印list内容的函数,
此时出现报错,其现在原因可能出在用了非const迭代器。
所以我们在list内 更新迭代器。
此时代码变过,但问题是,居然能修改const修饰的对象?! 这肯定超出了我们想要的效果。
问题出在:
所以,只有去再重新 单独创建一个const_iterator 才能实现。
然而,这样未免太过于繁琐,const迭代器与非const迭代器仅仅只有在一处地方 不同。
最后:
template<class T,class Ref,class Ptr>
struct _list_iterator
{
//再让节点在这个 结构体内重命名
typedef _list_node<T> node;
//牵涉一些运算
typedef _list_iterator<T, Ref, Ptr> self;
node* _pnode; //list迭代器 本质就是个 节点指针
_list_iterator(node* pnode)
:_pnode(pnode)
{}
//*
T& operator*()
{
return _pnode->_val;
}
//重载!=
bool operator!=(const self& s)
{
//两个地址不一样
return _pnode != s._pnode;
}
//前置++
self& operator++()
{
_pnode = _pnode->_next;
return *this;
}
//后置++
self operator++(int)
{
node* tmp = _pnode;
_pnode = _pnode->_next;
return tmp;
}
//前置--
self& operator--()
{
_pnode = _pnode->_prev;
return *this;
}
//后置
self operator--(int)
{
node* tmp = _pnode;
_pnode = _pnode->_prev;
return tmp;
}
};
各自会去找各自对应的部分。
list比较难的部分就是在于迭代器,搞定 这部分,之后的操作也就易如反掌
②属性:
size:
链表的size有两种方法:
1.计数++
size_t size()
{
size_t count = 0;
const_iterator it = begin();
while (it != end())
{
count++;
it++;
}
return count++;
}
2.定义类成员变量,动态增加。
empty:
bool empty()
{
//最初 头节点 的指针都是指向自己
return begin() == end();
}
③修改:
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->_prev = newnode;
}
push_front\pop_front\pop_back会采取复用的方式(insert\erase),
Insert:
void Insert(iterator pos, const T& x)
{
assert(pos._pnode);
//pos是迭代器 不是node
node* cur = pos._pnode;
node* prev = cur->_prev;
node* newnode = new node(x);
//newnode 链接在prev cur 之间
prev->_next = newnode;
newnode->_prev = prev;
cur->_prev = newnode;
newnode->_next = cur;
}
erase:
iterator erase(iterator pos)
{
assert(pos._pnode);
node* cur = pos._pnode;
node* prev = cur->_prev;
node* next = cur->_next;
delete cur;
prev->_next = next;
next->_prev = prev;
//返回下一个节点的迭代器
return iterator(next); //用next 去构造
}
pop\push:
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->_prev = newnode;
Insert(end(),x);
}
void push_front(const T& x)
{
Insert(begin(), x);
}
void pop_back()
{
erase(--end());
}
void pop_front()
{
erase(begin());
}
④构造与删除:
析构清除:
void clear()
{
iterator it = begin();
while (it != end())
{
//erase(it++);
it=erase(it);
}
}
~list()
{
clear();
delete _head;
_head = nullptr;
}
拷贝构造与赋值重载:
//拷贝构造
//l2(l1);
list(const list<T>& lt)
{
//构造头节点
_head = new node();
_head->_next = _head;
_head->_prev = _head;
//依次尾插
for (const auto& c : lt)
{
//不引用就是拷贝构造
push_back(c);
}
}
list<T>& operator=(list<T> v)
{
swap(_head,v._head);
return *this;
}
//s1=s2;
//传统写法
list<T>& operator=(list<T>& v)
{
if (this != &v)
{
//先清理自己
clear();
//再以次插入值
for (const auto& c : v)
{
push_back(c);
}
}
return *this;
}
构造:
//数值构造
list(size_t n, const T& val)
{
_head = new node(); //首先创建头节点
_head->_prev = _head;
_head->_next = _head; //指针指向自己
while (n--)
{
push_back(val);
}
}
//迭代区间
list(iterator first, iterator last)
{
_head = new node(); //首先创建头节点
_head->_prev = _head;
_head->_next = _head; //指针指向自己
while (first != last)
{
push_back(*first);
first++;
}
}
这篇list的短文也就结束了,希望对你有帮助
祝你好运~