向量

成员

• Rank _size
• int _capacity
• T* _elem

ADT接口

r为秩，e为元素

• size()
• get(r)
• put(r, e)
• insert(r, e)
• remove(r)
• disordered()
• sort()
• find(e)
• search(e) 有序
• deduplicate()
• uniquify() 有序
• traverse()

构造和析构

默认构造

Vector(int c = DEFAULT_CAPACITY, int s = 0, T v = 0) {
        _elem = new T[_capacity = c];
        for (_size = 0; _size < s; _elem[_size++] = v)
            ;
    }

• 可以指定容量，规模，所有元素初始值
  a = Vector(5,3,1) ：a[1,1,1]

• 未指定则默认
  b = Vector() : b 容量为DEFAULT_CAPACITY，规模为0

复制构造

数组

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) { coptFrom(V._elem, 0, V._size); }
Vector(Vector<T> const &V, Rank lo, Rank hi) { copyFrom(V._elem, lo, hi); }

二者均基于copyFrom()

template <typename T> void Vector<T>::copyFrom(T const *A, Rank lo, Rank hi) {
    _elem = new T[_capacity = 2 * (hi - lo)]; //扩容为2倍
    _size = 0; //规模清零
    while (lo < hi)
        _elem[_size++] = A[lo++];
}

这里的赋值符号=实际上应为向量对应数据的复制，若数据为向量，就需要重载运算符

template <typename T> Vector<T> &Vector<T>::operator=(Vector<T> const &V) {
    if (_elem)
        delete[] _elem;
    copyFrom(V._elem, 0, V.size());
    return *this;
}

析构

~Vector() { delete[] _elem; }

常规操作

访问元素

template <typename T> T &Vector<T>::operator[](Rank r) const {
    return _elem[r];
}

相当于a[1] == a._elem[1]

插入元素

template <typename T> Rank Vector<T>::insert(Rank r, T const &e) {
    expand();
    for (int i = _size; i > r; i--)
        _elem[i] = _elem[i - 1];
    _elem[r] = e;
    _size++;
    return r;
}

该操作将元素e插入位置r，插入的时候需要检测是否需要扩容

template <typename 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;
}

对于扩容函数：

• 若规模小于容量，显然无需扩容
• 若容量小于默认容量，容量改为默认容量
• 如需扩容，则扩为2倍