直接贴代码
Vector.h
#ifndef __LeetCode__Vector__
#define __LeetCode__Vector__
#include<iostream>
#include <string.h>
using namespace std;
typedef int Rank;//
static const int DEFAULT_CAPACITY = 3;
template <typename T> class Vector
{
protected:
Rank _size;
int _capacity;
T* _elem;
void copyFrom ( T const* A,Rank lo,Rank 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 merge ( Rank lo, Rank mi, Rank hi );
void mergeSort ( Rank lo,Rank mi ,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)//默認構造函數
{
_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 this->_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 <typename VST> void traverse ( VST& ); //遍历(使用函数对象,可全局性修改)
};
#endif /* defined(__LeetCode__Vector__) */
Vector.cpp
#include "Vector.h"
template <typename 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 ) //A[lo, hi)内的元素逐一
_elem[_size++] = A[lo++]; //复制至_elem[0, hi - lo)
}
template <typename T>
void Vector<T>::expand()
{
if(_size<_capacity) return;
_capacity = max(_capacity, DEFAULT_CAPACITY);
T oldeElem = _elem;
_elem = new T[_capacity <<= 1];
for (int i = 0; i<_size; i++)
{
_elem[i] = oldeElem;
}
delete [] oldeElem;
}
template <typename T>
T& Vector<T>::operator[] (Rank r)const {return _elem[r];}
template <typename T>
Rank Vector<T>::insert(Rank r,T const & e)
{
this->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;
this->shrink();
return hi -lo;
}
template <typename T>
T Vector<T>::remove(Rank r)
{
T e = _elem[r];
this->remove(r,r+1);
return e;
}
template <typename T>
Rank Vector<T>::find(const T &e, Rank lo, Rank hi) const
{
while ((lo < hi --) && ( e != _elem[hi]));
return hi;
}
template <typename T>
int Vector<T>::deduplicate()
{
int oldSize = this->_size;
Rank i = 1;
while (i < _size)
{
find(_elem[i],0,i)? i++ : remove(i);
}
return oldSize-_size;
}