vector的使用
#連續儲存結構：vector是可以實現動態成長的物件數組，支援對數組高效率的存取和在數組尾端的刪除和插入操作，在中間和頭部刪除和插入相對不易，需要挪動大量的資料。 （推薦學習：java課程）
它與陣列最大的差別就是vector不需程式設計師自己去考慮容量問題，函式庫裡面本身已經實現了容量的動態成長，而陣列需要程式設計師手動寫入擴容函數進形擴容。
Vector的模擬實作
template <class T>
class Vector
{
public:
typedef T* Iterator;
typedef const T* Iterator;
Vector()
:_start(NULL)
,_finish(NULL)
,_endOfStorage(NULL)
{}
void template<class T>
PushBack(const T& x)
{
Iterator end = End();
Insert(end, x);
}
void Insert(Iterator& pos, const T& x)
{
size_t n = pos - _start;
if (_finish == _endOfStorage)
{
size_t len = Capacity() == 0 ? 3 : Capacity()*2;
Expand(len);
}
pos = _start+n;
for (Iterator end = End(); end != pos; --end)
{
*end = *(end-1);
}
*pos = x;
++_finish;
}
Iterator End()
{
return _finish;
}
Iterator Begin()
{
return _start;
}
void Resize(size_t n, const T& val = T())//用Resize扩容时需要初始化空间，并且可以缩小容量
{
if (n < Size())
{
_finish = _start+n;
}
else
{
Reserve(n);
size_t len = n-Size();
for (size_t i = 0; i < len; ++i)
{
PushBack(val);
}
}
}
void Reserve(size_t n)//不用初始化空间，直接增容
{
Expand(n);
}
inline size_t Size()
{
return _finish-_start;
}
inline size_t Capacity()
{
return _endOfStorage-_start;
}
void Expand(size_t n)
{
const size_t size = Size();
const size_t capacity = Capacity();
if (n > capacity)
{
T* tmp = new T[n];
for (size_t i = 0; i < size; ++i)
{
tmp[i] = _start[i];
}
delete[] _start;
_start = tmp;
_finish = _start+size;
_endOfStorage = _start+n;
}
}
T& operator[](size_t pos)
{
assert(pos < Size());
return _start[pos];
}
const T& operator[](size_t pos) const
{
assert(pos < Size());
return _start[pos];
}
protected:
Iterator _start; //指向第一个元素所在节点
Iterator _finish; //指向最后一个元素所在节点的下一个节点
Iterator _endOfStorage; //可用内存空间的末尾节点
};list的使用
非連續儲存結構：list是雙鍊錶結構，支援對鍊錶的雙向遍歷。每個節點包含三個資訊：元素本身，指向前一個元素的節點（prev）和指向下一個元素的節點（next）。
因此list可以高效率的對資料元素任意位置進行存取和插入刪除等操作。由於涉及額外指針的維護，所以開銷比較大。
List的模擬實作
template<class T>
class List
{
typedef __ListNode<T> Node;
public:
typedef __ListIterator<T, T&, T*> Iterator;
typedef __ListIterator<T, const T&, const T*> ConstIterator;
Iterator Begin()
{
return _head->_next;
}
Iterator End()
{
return _head;
}
ConstIterator Begin() const
{
return _head->_next;
}
ConstIterator End() const
{
return _head;
}
List()
{
_head = new Node(T());
_head->_next = _head;
_head->_prev = _head;
}
// l2(l1)
List(const List& l)
{
_head = new Node(T());
_head->_next = _head;
_head->_prev = _head;
ConstIterator it = l.Begin();
while (it != l.End())
{
PushBack(*it);
++it;
}
}
~List()
{
Clear();
delete _head;
_head = NULL;
}
void Clear()
{
Iterator it = Begin();
while (it != End())
{
Node* del = it._node;
++it;
delete del;
}
_head->_next = _head;
_head->_prev = _head;
}
void PushBack(const T& x)
{
Insert(End(), x);
}
void PushFront(const T& x)
{
Insert(Begin(), x);
}
void PopBack()
{
Erase(--End());
}
void PopFront()
{
Erase(Begin());
}
void Insert(Iterator pos, const T& x)
{
Node* cur = pos._node;
Node* prev = cur->_prev;
Node* tmp = new Node(x);
prev->_next = tmp;
tmp->_prev = prev;
tmp->_next = cur;
cur->_prev = prev;
}
Iterator Erase(Iterator& pos)
{
assert(pos != End());
Node* prev = (pos._node)->_prev;
Node* next = (pos._node)->_next;
prev->_next = next;
next->_prev = prev;
delete pos._node;
pos._node = prev;
return Iterator(next);
}
protected:
Node* _head;
};vector 和list的區別
*vector的隨機存取效率高，但在插入和刪除時（不包括尾部）需要挪動數據，不易操作。
*List的存取要遍歷整個鍊錶，它的隨機存取效率低。但對資料的插入和刪除操作等都比較方便，改變指針的指向即可。
*list是單向的，vector是雙向的。
*vector中的迭代器在使用後就失效了，而list的迭代器在使用後還可以繼續使用。
以上是java的vector與list區別的詳細內容。更多資訊請關注PHP中文網其他相關文章！
