大二的时候在听邓公的课上手抄的(手打算不算原创啊)
ლ(ó﹏òლ)对不起
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);
}
}