Vector和List

Vector和List的区别：

1.vector数据结构
vector和数组类似，拥有一段连续的内存空间，并且起始地址不变。
因此能高效的进行随机存取，时间复杂度为o(1);
但因为内存空间是连续的，所以在进行插入和删除操作时，会造成内存块的拷贝，时间复杂度为o(n)。
另外，当数组中内存空间不够时，会重新申请一块内存空间并进行内存拷贝。

2.list数据结构
list是由双向链表实现的，因此内存空间是不连续的。
只能通过指针访问数据，所以list的随机存取非常没有效率，时间复杂度为o(n);
但由于链表的特点，能高效地进行插入和删除。

模拟实现MyVector:

#include<iostream>  
#include<assert.h>  
using namespace std;  
  
template <class T>  
class Vector  
{  
public:  
    typedef T* Iterator;  
    typedef const T* ConstIterator;  
public:  
    Vector()  
        :_start(NULL)  
        ,_finsh(NULL)  
        ,_endOfStorage(NULL)  
    {}  
    void PushBack(const T& x)  
    {  
        Iterator end = End();  
        Insert(end,x);  
    }  
    void Insert(Iterator& pos,const T& x)  
    {  
        size_t n = pos - _start;  
        if(_finsh == _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;  
        ++_finsh;  
    }  
    void Erase(Iterator& pos)  
    {  
        assert(pos);  
        for(Iterator start = pos;start != End();++start)  
        {  
            *start= *(start+1);   
        }  
        --_finsh;  
    }  
    void PopBack()  
    {  
        if(_start == NULL)  
        {  
            return;  
        }  
        --_finsh;  
    }  
    void Resize(size_t n,const T& val = T())  
    {  
        if(n<Size())  
        {  
            _finsh = _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);  
    }  
    size_t Size()  
    {  
        return _finsh-_start;  
    }  
    size_t Capacity()  
    {  
        return _endOfStorage-_start;  
    }  
    Iterator End()  
    {  
        return _finsh;  
    }  
    Iterator Begin()  
    {  
        return _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;  
            _finsh = _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 _finsh;  
    Iterator _endOfStorage;  
};  

模拟实现MyList：

#include <iostream>  
#include<assert.h>  
using namespace std;  
  
template<class T>  
struct __ListNode  
{  
    T _data;  
    __ListNode<T>* _prev;  
    __ListNode<T>* _next;  
    __ListNode<T>(const T& x)  
        :_data(x)  
        ,_next(NULL)  
        ,_prev(NULL)  
    {}  
};  
template <class T,class Ref,class Ptr>  
class __ListIterator   
{     
public:  
    typedef __ListNode<T> Node;  
    typedef __ListIterator <T,Ref,Ptr> Iterator;  
    __ListIterator(Node* node)  
        :_node(node)  
    {}  
  
    bool operator == (const Iterator& x)  
    {  
        return _node == x._node;  
    }  
    bool operator != (const Iterator& x)  
    {  
        return _node != x._node;  
    }  
    Iterator operator ++() //前置  
    {  
        _node = _node->_next;  
        return *this;  
    }  
    Iterator operator ++(int)//后置  
    {  
        Iterator tmp = *this;  
        _node = _node->_next;  
        return tmp;  
    }  
    Iterator operator --()//前置  
    {  
        _node = _node->_prev;  
        return *this;  
    }  
    Iterator operator --(int)//后置  
    {  
        Iterator tmp = *this;  
        _node = _node->_prev;  
        return tmp;  
    }  
    Ref operator *()//解引用  
    {  
        return _node->_data;  
    }  
    Ptr operator ->()//指针  
    {  
        return &(_node->_data);  
    }  
    const Ref operator *()const  
    {  
        return _node->_data;  
    }  
    const Ptr operator ->()const  
    {  
        return &(_node->_data);  
    }  
    Node* _node;  
};  
template <class T>  
class List  
{  
    typedef __ListNode<T> Node;  
public:  
    typedef __ListIterator <T,T&,T*> Iterator;  
    typedef __ListIterator <T,const T&,const T*> ConstIterator;  
    /*Node* GetNode(const T& x) 
    { 
        return new Node(x); 
    } 
 
    List() 
    { 
        _head = GetNode(T()); 
        _head->_next = _head; 
        _head->_prev = _head; 
    }*/  
    List()//无参构造函数  
    {  
        _head = new Node(T());  
        _head->_prev = _head;  
        _head->_next = _head;  
    }  
    List(const T& x)//有参构造函数  
        :_head(new Node(x))  
    {  
        _head->_next = _head;  
        _head->_prev = _head;  
    }  
    ~List()  
    {  
        Clear();  
        delete _head;  
        _head = NULL;  
    }  
    Iterator Begin()  
    {  
        return Iterator(_head->_next);  
    }  
    Iterator End()  
    {  
        return Iterator(_head);  
    }  
    ConstIterator Begin()const  
    {  
        return Iterator(_head->_next);  
    }  
    ConstIterator End()const  
    {  
        return Iterator(_head);  
    }  
    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)  
    {  
        /*Node* tmp = new Node(x); 
        Node* tail = _head->_prev; 
 
        tail->_next = tmp; 
        tmp->_prev = tail; 
 
        tmp->_next = _head; 
        _head->_prev = tmp;*/  
        Insert(End(),x);  
    }  
    void PushFront(const T& x)  
    {  
        Insert(Begin(),x);  
    }  
    //在pos的前面插入  
    void Insert(Iterator pos,const T& x)  
    {  
        Node* cur = pos._node;  
        Node* prev = cur->_prev;  
        Node* tmp = new Node(x);  
  
        prev->_next = tmp;  
        tmp->_next = cur;  
        cur->_prev = tmp;  
        tmp->_prev = prev;  
    }  
    void PopFront()  
    {  
        Erase(Begin());  
    }  
    void PopBack()  
    {  
        Erase(--End());  
    }  
    Iterator Erase(Iterator pos)  
//有迭代器失效的问题，所以此处返回要删除的节点的下一个位置的迭代器  
    {  
        assert(pos != End() && pos._node);  
        Node* cur = pos._node;  
        Node* prev = cur->_prev;  
        Node* next = cur->_next;  
  
        prev->_next = next;  
        next->_prev = prev;  
        delete cur;  
  
        //pos._node = prev;  
  
        return next;  
    }  
    Iterator Find(const T& x)  
    {  
        Iterator it = Begin();  
        while(it != End())  
        {  
            if(*it == x)  
            {  
                return it;  
            }  
            ++it;  
        }  
    }  
    bool Empty()  
    {  
        return _head = _head->_next;  
    }  
  
protected:  
    Node* _head;  
};  
void Print(List<int>& l)  
{  
    List<int>::Iterator it = l.Begin();  
    while(it != l.End())  
    {  
        cout<<*it<<" ";  
        ++it;  
    }  
    cout<<endl;  
}