无序向量Vector

向量vector

1、AbstractData Type(ADT)抽象数据类型：数据模型上定义的一种操作。Data structure数据结构：基于某种特定语言，实现ADT的一整套算法。向量是数组的抽象和泛化，有一组元素按线性顺序封装而成。

ADT操作接口：

 

2、vector模板类

（1）基于复制的构造

template<typename T>

voidVector<T>::copyFrom(T* const A,Rank lo,Rank hi)

{

    _elem=new T[_capacity=2*(hi-lo)];//申请空间

            _size=0;

            while(lo<hi)

            _elem[_size++]=A[lo++];

}

一般都以左闭右开，A[lo,hi)，所以总共长度是hi-lo，hi不属于vector的，可以当做哨兵使用。

（2）扩容expand()

上溢overflow，下溢underflow.动态空间管理：在即将发生上溢时，适当地扩大内部数组的容量。

template<typename T>

voidVector<T>::expand()

{

    if(_size<_capacity) return;

    T *oldElem=_elem;    //备份

    _elem=new T[capacity<<=1]; //容量加倍

    for(int i=0;i<_size;i++)

      _elem[i]=oldElem[i];

    delete [] oldElem;  //释放空间

}

为什么需要容量加倍呢？下图是递增扩容和加倍扩容。

平均复杂度average/expected complexity，是独立的过程。

分摊分析amortized complexity，连续的操作，更加贴近实际。

3、无序向量

template <typename T> Vector{...};定义一系列vector:

例如Vector<int> myVector… Vector<BinTree > myVector…

（1）元素访问：重载操下标操作符[]

template<typename T>

T&Vector<T>::operator[](Rank r)const

{

    return _elem[r];

}

（2）插入元素insert( )

template<typename T>  //把e作为秩r的元素插入

RankVector<T>::insert(Rank r,T const &e)

{

    expand();  //扩容

    for(int i=_size;i>r;i--)

    _elem[i]=_elem[i-1];   //将元素往后移动，直到移动到r

_elem[r]=e;_size++;

return  r;

}

 

(3) 区间删除remove(),复杂度O(n-hi)

template <typename T> //删除区间[lo,hi)

int Vector<T>::remove(Rank lo,Rank hi)

{

    if(lo==hi)  return 0;

while(hi<_size) _

elem[lo++]=_elem[hi++]; //顺次往前移动hi-lo位

    _size=lo;shrink();

    return hi-lo;

}

(4)单元素删除remove(),复杂度为O(n-r)

template <typename T>

T Vector<T> ::remove(Rank r)

{

    T e=_elem[r];

    remove(r,r+1);

    return e;

}

如果区间删除调用单元素删除的话，理论上是可以的，但是复杂度的话每次调用都需要O(n-r)，这样级数相加，最后区间删除的复杂度有可能是O(n²)。

（５）查找操作find无需判断一般只支持判等操作，有序向量支持比较操作

template <typename T>  //查找在区间lo，hi之间的元素,靠近hi 

Rank Vector<T>::find(T const &e,Rank lo,Rank hi) const

{

    while((lo<hi--)&&(e!=_elem[hi]));//持续到成功为止才退出循环

    return hi;

}最好O(1),最差O(n)

(6)唯一化deduplicate( )去重操作:经过查找函数，如果有的话删除

template<typename T>

intVector<T>::deduplicate()

{

    int oldSize=_size;

    Rank i=1;

    while(i<_size)

     (find(_elem[i],0,i)<0)?i++:remove(i);//如果找到元素则删除，否i++

    return oldSize-_size; //返回删除的元素个数

}

对于find,remove每次迭代最多是O(n),所以最坏的复杂度是O(n2)。