vector和list的区别,vector是list的实现类吗
vector和list的区别
vector的随机存取效率高，但由于插入和删除时需要移动数据(不包括尾部)，操作起来比较困难。
链表的访问必须遍历整个链表，随机访问效率低。不过，插入和删除数据很方便，只需改变指针。
列表是单向的，向量是双向的。
Vector中的迭代器使用后会失效，而list中的迭代器使用后可以继续使用。
vector的使用
连续存储结构：vector是一个可以动态增长的对象数组。它支持对数组的高效访问以及在数组末尾的删除和插入。中间和头部的删除和插入相对困难，需要移动大量数据。vector和array最大的区别在于，Vector不需要程序员考虑容量问题，库本身实现了容量的动态增长，array则需要程序员手动编写扩展函数来扩展容量。
矢量的仿真实现
模板类T
分类向量
{
公共：
typedef T*迭代器；
typedef const T * Iterator
向量()
:_start(空)
，_完成(空)
，_endOfStorage(空)
{}
void模板类T
推回(常数T x)
{
迭代器End=End()；
Insert(end，x)；
}
空插入(迭代器位置，常量x)
{
size _ t n=pos-_ start；
if (_finish==_endOfStorage)
{
size_t len=Capacity()==0？3:容量()* 2；
expand(len)；
}
pos=_ start n；
for(迭代器End=End()；结束！=pos-结束)
{
* end=*(end-1)；
}
* pos=x；
_完成；
}
迭代器结束()
{
返回_完成；
}
迭代器Begin()
{
返回_开始；
}
Void Resize (size _ t n，const t val=t())//当使用Resize来扩展容量时，需要初始化空间，可以减少容量。
{
if (n Size())
{
_ finish=_ start n；
}
其他
{
储备(n)；
Size _ t len=n-Size()；
for(size _ t I=0；我len我)
{
推回(val)；
}
}
}
Void Reserve(size_t n)//不初始化空间直接增加容量
{
展开(n)；
}
inline size_t Size()
{
return _ finish-_ start；
}
inline size_t容量()
{
return _ endof storage-_ start；
}
无效扩展(大小为n)
{
const Size _ t Size=Size()；
const size _ t Capacity=Capacity()；
中频(n容量)
{
T * tmp=new T[n]；
for(size _ t I=0；I尺寸；我)
{
tmp[I]=_ start[I]；
}
delete[]_ start；
_ start=tmp
_ finish=_ start size
_ endof storage=_ start n；
}
}
测试运算符[](size_t pos)
{
assert(pos Size())；
return _ start[pos]；
}
常量T运算符[](size_t pos)常量
{
assert(pos Size())；
return _ start[pos]；
}
受保护：
Iterator _ start//指向第一个元素所在的节点
Iterator _ finish//指向最后一个元素所在节点的下一个节点
Iterator _ endOfStorage//可用内存空间的结束节点
};list的使用
不连续存储结构：list是一种双向链表结构，支持链表的双向遍历。每个节点包括三条信息：元素本身、指向前一个元素的节点(prev)和指向下一个元素的节点(next)。因此，list可以在任何位置高效地访问、插入和删除数据元素。因为涉及到额外指针的维护，开销比较大。
列表的模拟实现
模板类T
根据考试成绩分等级排列的投考者的名单
{
typedef __ListNodeT节点；
公共：
typedef _ _ ListIteratorT，T，T*迭代器；
typedef _ _ ListIteratorT，const T，const T * ConstIterator
迭代器Begin()
{
return _ head-_ next；
}
迭代器结束()
{
return _头；
}
ConstIterator Begin()常量
{
return _ head-_ next；
}
ConstIterator End() const
{
return _头；
}
列表()
{
_head=新节点(T())；
_ head-_ next=_ head；
_ head-_ prev=_ head；
}
//l2(l1)
列表(常量列表l)
{
_head=新节点(T())；
_ head-_ next=_ head；
_ head-_ prev=_ head；
ConstIterator it=l . Begin()；
而（它！=l.End())
{
推后(* it)；
它；
}
}
~列表()
{
clear()；
删除_头
_ head=NULL
}
空清除()
{
迭代器it=Begin()；
而（它！=End())
{
Node* del=it ._ node
它；
删除倒三角形
}
_ head-_ next=_ head；
_ head-_ prev=_ head；
}
无效推回（常数x)
{
Insert(End()，x)；
}
无效推进（常数x)
{
Insert(Begin()，x)；
}
void PopBack()
{
erase(-End())；
}
void PopFront()
{
erase(Begin())；
}
空插入（迭代器位置，常量x)
{
节点*当前=位置. node节点
node * prev=cur-_ prev；
节点* tmp=新节点；
prev-_ next=tmp；
tmp-_ prev=prev；
tmp-_ next=cur；
cur-_ prev=prev；
}
迭代器擦除（迭代器位置)
{
断言（位置！=End())；
Node* prev=(位置. node)_ prev；
Node* next=(位置. node)_ next；
prev-_ next=next；
next-_ prev=prev；
删除位置. node节点
位置. node=prev
返回迭代器（下一个);
}
受保护：
节点* _头
};推荐学习：Java视频教程以上就是爪哇岛中矢量与目录的区别是什么？的详细内容，更多请关注我们其它相关文章！
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。