2.1 向量接口

向量是一种抽象数据类型（ADT。Abstract data type），所谓抽象数据类型，就是通过封装，将数据项与想过操作结合成一个整体，并将其从外部的可见性划分为若干级别，从而将数据类型的外部特征与其内部实现相分离，提供一致标准的对外接口，从而对数据集合及其对应的操作可超脱于具体的程序设计语言、具体的实现方式。正是抽象数据类型理论，催生了现代面对对象的程序设计语言，从而支持封装也是此类语言的基本特征。

 

作为一种抽象数据类型，向量（vector）支持以下的操作接口：

 

size()                        报告向量当前规模（元素总数）                        向量

get(r)                        获取秩为r的元素                                              向量

put(r, e)                    用e替换秩为r元素的数值                                  向量

insert(r,e)                  e作为秩为r元素插入，原后继元素依次后移      向量

remove(r)                 删除秩为r的元素，返回该元素中原存放的对象  向量

disordered()             判断所有元素是否已经按照非降序排列             向量

sort()                        调整各元素的位置，使之按照非降序排列          向量                                            

find(e)                       查找等于e且秩最大的元素                               向量

search(e)                   查找目标元素e，返回不大于e且秩最大的元素  有序向量

deduplicate()            剔除重复元素                                                   向量

uniquify()                  剔除重复元素                                                   有序向量

traverse()                  遍历向量并统一处理所有元素，方式由函数指定 向量

 

向量类模板的代码如下：

 

/******************************************************************************************

 * Data Structures in C++

 * ISBN: 7-302-33064-6 & 7-302-33065-3 & 7-302-29652-2 & 7-302-26883-3

 * Junhui DENG, deng@tsinghua.edu.cn

 * Computer Science & Technology, Tsinghua University

 * Copyright (c) 2006-2013. All rights reserved.

  ******************************************************************************************/

#pragma once

typedef int Rank; //秩

#define DEFAULT_CAPACITY  3 //默认的初始容量（实际应用中可设置为更大）

template <typename T> class Vector { //向量模板类

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 merge ( 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 ); } //s<=c

   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 <typename VST> void traverse ( VST& ); //遍历（使用函数对象，可全局性修改）

}; //Vector

#include "vector_implementation.h"

 

以上模板中的许多算法实例将在后续几节中讨论和使用。

转载于:https://www.cnblogs.com/NK-007/p/9182563.html