Vector C++实现（在校旧文）

大二的时候在听邓公的课上手抄的（手打算不算原创啊）
ლ(ó﹏òლ)对不起

Vector 实现如下，包括了几种排序算法：

typedef int rank; //秩 
#define DEFAULT_CAPACITY 3 //默认初始容量 
template <tempname T> class Vector{ //向量模板类 
private:
protected:
    Rank _size;int _capacity;T* _elem; //规模、容量、数据区
    void copyFrom (T const*A,Rank lo,Rank hi);//复制数组区间A[lo,hi)
    void expand();//空间不足时扩容
    void shrink();//填装因子过小时压缩
    bool bubble(Rank lo,Rank hi);//扫描交换
    void bubbleSort(Rank lo,Rank hi);//气泡排序算法
    Rank max(Rank lo,Rank hi);//选取最大元素
    void selectionSort(Rank lo,Rank hi);//选择排序算法
    void mergr(Rank lo,Rank mi,Rank hi);//归并算法
    void mergeSort(Rank lo,Rank hi);//归并排序算法
    Rank partition(Rank lo,Rank hi);//轴点构造算法
    void quickSort(Rank lo,Rank hi);//快速排序算法
    void heapSort(Rank lo,Rank hi);//堆排序 
/*...内部函数*/
public: 
//构造函数
    Vector( int c = DEFAULT_CAPACITY, int s = 0, T v = 0) {//容量为c 规模为s 所有元素初始为v 
        _elem = new T[_capacity = c] ;
        for( _size = 0; _size < s; _elem[_size++] = v);
    }
    Vector(T const* A, Rank n){//数组整体复制 
        copyFrom(A, 0, n);
    }
    Vector(T const*A, Rank lo, Rank hi){//数组区间复制 
        copyFrom(A, lo, hi);
    }
    Vector(Vector<T> const& V){//向量整体复制 
        copyFrom(V._elem, 0, V._size);
    }
    Vector(Vector<T> const& V, Rank lo, Rank hi) { //向量区间复制 
        copyFrom(V._elem, lo, hi);
    }
//析构函数
    ~Vector(){//释放内存空间 
        delete [] _elem;
    } 
// 只读访问接口
    Rank size() const {//规模 
        return _size;
    }
    bool empty() const {//判空 
        return !_size;
    } 
    int disordered() const;//判断向量是否已排序
    Rank find(T const& e) const{
        return find(e, 0, _size);//无序向量整体查找 
    } 
    Rank find(T const& e, Rank lo, Rank hi) const;//无序向量区间查找
    Rank search(T const& e) const {//有序向量整体查找 
        return (0 >= _size) ? -1 : search(e, 0, _size);
    } 
    Rank search(T const& e, Rank lo, Rank hi) const;//有序向量区间查找
    //可写访问接口
    T& operator[](Rank r) const;//重写下标操作符，可以类似数组形式引用各个元素
    Vector<T> & operator = (Vector<T> const&);//重写赋值操作符，可以直接克隆向量
    T remove(Rank r); //删除秩为r的元素
    int remove(Rank lo, Rank hi); //删除秩在区间[lo,hi]之内的元素
    Rank insert(Rank r, T const& e); //插入元素
    Rank insert(T const& e){//默认作为末元素插入 
        return insert (_size, e);
    } 
    void sort (Rank lo, Rank hi);//对[lo,hi)排序
    void sort (){//整体排序 
        sort(0, _size);
    } 
    void unsort(Rank lo, Rank hi); //对[lo,hi)置乱
    void unsort(){//整体置乱 
        unsort(0, _size);
    } 
    int deduplicate();//无序去重
    int uniquify();//有序去重
    //遍历
    void traverse(void (* ) (T& ));//遍历（使用函数指针，只读或局部性修改）
    template <tempname VST> void traverse (VST& );//遍历（使用函数对象，可全局性修改） 
};
// copyFrom 的实现 
template <tempname T>//元素类型 
void Vector<T>::copyFrom(T const& A, Rank lo, Rank hi){ //以数组区间A[lo,hi)为蓝本复制向量 
    _elem = new T[_capacity = 2 * (hi - lo)];
    _size = 0; //分配空间，规模清零 
    while(lo<hi){//逐一复制 
        _elem[_size++] = A[lo++];
    }
}
 // 赋值运算符的重载 
template <tempname T>
Vector<T>& Vector<T>::operator = (Vector<T> const& V){//重载赋值运算符 
    if(_elem){//释放原有空间 
        delete [] _elem;
        copyFrom(V._elem, 0, V._size);//整体复制
        return *this;//返回当前对象的引用，以便链式赋值 
    } 
} 
//扩容 
template <tempname T> void Vector<T>::expand(){ //向量空间不足时扩容 
    if(_size < _capacity) return;//尚未满员时，不必扩容 
    if(_capacity < DEFAULT_CAPACITY) _capacity = DEFAULT_CAPACITY;//不低于最小容量
    T* oldElem = _elem;
    _elem = new T[_capacity <<= 1];//容量加倍
    for(int i = 0, i < _size; i++){
        _elem[i] = oldElem[i];//复制原向量内容 
    }  
    delete [] oldElem;//释放原空间 
} 
//缩容 
template <tempname T> void Vector<T>::shrink(){//装填因子过小时压缩向量所占的容量 小于1/4时减半 
    if(_capacity < DEFAULT_CAPACITY << 1) return;//不致收缩到DEFAULT_CAPACITY以下
    if(_size << 2 >_capacity) return;//以25%为界
    T* oldElem = _elem;
    _elem = new T[_capacity >>= 1];//容量减半
     for(int i = 0; i < size; i++){
        _elem[i] = oldElem[i];//复制原向量内容 
     }
     delete [] oldElem;//释放原空间 
}
//直接引用元素 重载向量操作符[]
template <tempname T> T& Vector::operator[](Rank r) const{
    return _elem[r];//assert 0 <= r < _size
} 
//置乱器
template <tempname T> void Vector<T>::permute(Vector<T>& V){
    for(int i = V.size(); i > 0; i--){//自后向前 
        swap(V[i-1], V[rand() % i]);//V[i-1] 与 V[0，i)中某一个随机元素交换 
    }
}
//向量区间置乱器
template <tempname T> Vector<T>::unsort(Rank lo, Rank hi){
    T* V = _elem + lo;
    for(Rank i = hi - lo; i > 0; i--){
        swap(V[i - 1],rand() % i);
    }
}