【数据结构实现】Vector顺序表

目的：
1.练习泛型语法
2.练习面向对象
3.练习接口设计
4.学习邓俊辉老师的《数据结构》

typedef int Rank;
#define DEFAULT_CAPACITY  3

template <typename T> 
class Vector
{
public:
//构造函数
    Vector(int c = DEFAULT_CAPACITY, int s = 0, T v = 0)
        : capacity_(c)
        , size_(s)
    {
        elem_ = new T[capacity_];
        for ( int i = 0; i < size_; i++)
        {
            elem_[i] = v;
        }
    }


//析构函数
    ~Vector()
    {
        delete[] elem_;
    }

//只读访问接口
    Rank size() const { return size_; }

    bool empty() const { return !size_; }

    Rank find(T const& e ,Rank lo, Rank hi) const;

    Rank find(T const& e) const { return find(e, 0, (Rank)size_); }

    bool isdisordered() const;

//可写访问接口
    T& operator[](Rank r) const; 

    Rank insert(Rank r, T const& e);

    Rank insert(T const& e) { return insert(size_, e); }

    T remove(Rank r);

    int remove(Rank lo, Rank hi);

    int deduplicate();

    int uniquify();

protected:
    void copyFrom(T const* A, Rank lo, Rank hi);
    void expand();
    void shrink();

    Rank size_;
    int capacity_;
    T* elem_;    
};


template <typename T>
void Vector<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++];
    }
}

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

template <typename T>
void Vector<T>::shrink()
{
    if ( capacity_ < DEFAULT_CAPACITY << 2 ) return ;
    if ( size_ << 2 >  capacity_ ) return ;
    T* oldElem = elem_;
    elem_ = new T[capacity_ >>= 1];
    for (int i = 0; i < size_; i++)
    {
        elem_[i] = oldElem[i];
    }
    delete[] oldElem;
}

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

template<typename T>
Rank Vector<T>::find(T const& e, Rank lo, Rank hi) const
{
    while ((lo < hi--) && (e != elem_[hi]));
    return hi;
}

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

template<typename T>
int Vector<T>::remove(Rank lo, Rank hi)
{
    if (lo == hi)
        return 0;
    while (hi < size_)
    {
        elem_[lo++] = elem_[hi++];
    }
    size_ = lo;
    shrink();
    return hi - lo;
}


template<typename T>
T Vector<T>::remove(Rank r)
{
    T e = elem_[r];
    remove(r, r+1);
    return e;   
}

template<typename T>
int Vector<T>::deduplicate()
{
    int oldSize_ = size_;
    Rank i = 1;
    while(i < size_)
    {
        (find(elem_[i], 0, i) < 0)? i++ : remove(i);
    }
    return oldSize_ - size_;
}

template<typename T>
bool Vector<T>::isdisordered() const
{
    for (int i = 1; i < size_; i++)
    {
        if (elem_[i - 1] > elem_[i])
            return false;     
    }
    return true;
}

template<typename T>
int Vector<T>::uniquify()
{
    int oldSize_ = size_;
    Rank i = 0;
    while(i < size_)
    {
        (elem_[i] == elem_[i+1]) ? remove(i+1) : i++;
    }
    return oldSize_ - size_;
}