2.2 列表
向量结构中,各数据的物理存放位置与逻辑次序完全对应,故可通过秩直接访问对应的元素,这称为循秩访问。为保证对列表元素访问的可行性,逻辑上互为前驱和后继的元素之间,应维护某种索引关系。这种索引关系可被抽象地理解为被索引元素的位置,故列表元素是循位置访问的。
2.2.1 向量到列表
引入列表结构的目的在于弥补向量结构在解决某些应用问题时,在功能及性能方面的不足,二者差异的根源在于其内部存储方式的不同。列表结构尽管也要求各元素在逻辑上具有线性次序,但对其物理地址却未做任何限制,这就是所谓的动态存储策略。在其生命周期内,此类数据结构将随着内部数据的需要,相应地分配或回收局部的数据空间。作为补偿,此类结构将通过指针和引用等机制,来确定各元素的实际物理地址。链表就是一种典型的动态存储结构。采用动态存储策略,至少可以大大降低动态操作的成本。
与向量中秩的地位和功能类似,列表中的位置也是指代各数据元素的一个标识性指标,借助它可以便捷地得到元素的物理存储地址。各元素的位置,通常可以表示为连接于元素之间的指针或引用。
列表与向量一样,也是由具有线性逻辑次序的一组元素构成的集合:L={a0.......an-1}。列表是链表结构的一般化推广,其中的元素称为节点Node。
2.2.2 接口
列表节点的ADT接口 |
列表的ADT接口 |
data() //当前节点所存数据对象 pred() //当前节点前驱节点的位置 succ() //当前节点后继节点的位置 insertAsPred(e) //插入前驱节点,存入被引用对象e,返回新节点位置 insertAsSucc(e) //插入后继节点,存入被引用对象e,返回新节点位置 |
size()//报告列表当前的规模(节点总数) first()//返回首元素位置 insertAsFirst(e)//将e当作首节点插入 insertBefore(p,e)//将e当作节点p的直接前驱 remove(p)//删除p处节点,返回其数值 sort()//调整各节点位置,使之按非降序排列 find(e)//查找目标元素e deduplicate()//删除重复节点 |
header称为头哨兵,trailer称为尾哨兵。列表结构的实现方式类似于向量结构:通过模版参数T指定列表元素的类型,在内部设置私有变量以记录当前规模等状态信息,基于多种排序算法提供统一的sort()接口,将列表转化为有序列表。
2.2.3 列表
一、头、尾节点
List对象的内部组成与逻辑结构如图2.1所示,其中私有的头结点header和尾节点trailer始终存在,对外不可见。虚线框内是对外可见的数据节点,其中的第一个和最后一个节点分别称作首节点firstNode和末节点lastNode。头节点紧邻于首节点之前,尾节点紧邻于末节点之后。这类封装之后从外部不可见的节点称作哨兵节点。
图 2.2 首(末)节点是头(尾)节点的直接后继(前驱)
二、默认构造方法
创建List对象时,默认构造方法将调用统一初始化过程init(),在列表内部创建一对头尾哨兵节点,并适当地设置其前驱、后继指针,构成一个双向链表。该链表对外的有效部分初始为空。
template <typename T>
typedef int Rank;//自定义数据类型Rank,它是整形的
#define ListNodePosi(T) ListNode<T>* //列表节点的位置,每个节点都是一个结构体
void List<T>::init() //列表初始化,在创建列表对象时统一调用
{
header=new ListNode<T>;//创建头哨兵节点
trailer=new ListNode<T>;//创建尾哨兵节点
header->succ=trailer;//header的后继节点是trailer
header->pred=NULL;
trailer->pred=header;trailer->succ=NULL;
_size=0;//记录规模
}
三、查找
列表ADT中针对整体与区间的查找,重载了接口find(e)和find(e,p,n)。前者作为特例,可直接调用后者。
template <typename T>
ListNodePosi(T) List<T>::find(T const& e,int n,ListNodePosi(T) p) const
// ListNodePosi(T) 是列表节点的位置类型,是一个指针,在前面宏定义过
//0<=n<=rank(p)<_size
{
while(0<n--) //对于p最近的n个前驱,从右到左
if (e==(p=p->pred)->data) return p;
//逐个比对,直至命中或越界,p->pred指的是获得p指向的对象的pred成员
return NULL;
}
四、插入
将节点插入列表有多种方法,列表提供了多种接口
template <typename T>
ListNodePosi(T) List<T>::insertAsFirst(T const &e) //将e当作首节点插入
{
_size++; return header->insertAsSucc(e);
//首先使规模加1,然后调用头结点header的insertAsSucc()函数,在后面插值
}
template <typename T>
ListNodePosi(T) List<T>::insertAsLast(T const &e) //将e当作末节点插入
{
_size++; return trailer->insertAsPred(e);
}
template <typename T>
ListNodePosi(T) List<T>::insertBefore(ListNodePosi(T) p, T const &e)//将e当作p的前驱插入
{
_size++; return p->insertAsPred(e);//调用节点p的insertAsPred()函数,在前面插值
template <typename T>
ListNodePosi(T) List<T>::insertAfter(ListNodePosi(T) p, T const &e)//将e当作p的后继插入
{
_size++; return p->insertAsSucc(e);
}
列表节点对象的前插入接口 |
列表节点对象的后插入接口 |
将新元素e作为当前节点的前驱插至列表。具体操作如下:首先创造新节点new,构造函数的同时使其数据项为e,后继链接succ指向当前节点this,令其前驱链接pred指向当前节点的前驱节点;然后使new成为当前节点的前驱节点的后继,使new称为当前节点的前驱,这个次序不能颠倒。 |
将新元素e作为当前节点的后继插至列表。道理和前插是一样。 |
|
|
五、基于复制的构造
通过复制某一已有列表来构造新列表,在输入参数合法的前提下,copyNodes()首先调用init()方法,创建头尾哨兵节点并作相应的初始化处理,然后自p所指节点起,从原列表中取出n个相邻的节点,并逐一作为末节点插至新列表中。
template <typename T>
void List<T>::copyNodes(ListNodePosi(T) p, int n)
//复制列表自p开始的n项,p合法且至少有n-1个真后继节点
{
init();//创建头尾哨兵节点并初始化
while(n--)
{
insertAsLast(p->data);
p=p->succ;
}
六、删除
删除指定节点p,首先令p的前驱节点和后继节点互相连接,然后释放掉已经被孤立出来的节点p,同时相应的更新列表规模计数器_size。
template <typename T>
T List<T>::remove(ListNodePosi(T) p) //删除合法位置p处的节点
{
T e=p->data; //备份待删除节点的数据
p->pred->succ=p->succ;
//p->pred是p的前驱元素,p->pred->succ指的是p的前驱元素的后继元素
p->succ->pred=p->pred;
delete p;//释放节点p
_size--;//更新规模
return e;//返回备份的数据
}
七、析构
释放资源及清除节点,列表的析构首先要调用clear()接口删除并释放所有对外有效的节点,然后释放内部的头尾哨兵节点。
template <typename T>
List<T>::~List()
{
clear();//清空列表
delete header; delete trailer;//释放头、尾哨兵节点
}
template <typename T>
int List<T>::clear()
{
int oldSize=_size;
while(0<_size) remove(header->succ);//反复删除首节点
return oldSize;
}
八、唯一化
用于删除无序列表中重复元素的接口deduplicate(),类似于Vector::deduplicate(),都是自前向后依次处理各节点p,一旦通过find()找到相同者,就调用remove()。
template <typename T>
int List<T>::deduplicate() //删除无序列表中的重复节点
{
if(_size<2) return 0;平凡列表自然无覆盖
int oldSize=_size;//记录原规模
ListNodePosi(T) p=header; Rank r=0; //p从首节点开始
while(trailer!=(p=p->succ))
{
ListNodePosi(T) q=find(p->data,r,p); //在p的r个前驱中寻找相同的
q? remove(q):r++; //若存在则删除,否则秩加一
}
return oldSize-_size;//返回被删除的元素总数
}
2.2.4 有序列表
若列表中所有节点的逻辑次序与其大小次序完全一致,则称作有序列表。为保证节点间可以定义次序,假定元素类型T可以直接支持大小的比较。
一、唯一化
与有序向量同理,有序列表中相同的节点也必然在逻辑上彼此相邻。利用这一特性,可以实现有序列表的重复节点删除算法uniquify()。指针p和q分别指向每一对相邻的节点,若2者相同时则删除q,否则转向下一对相邻节点。如此反复直至检查过所有节点。
template <typename T>
int List<T>::uniquify() //成批删除重复元素
{
if (_size<2) return 0;
int oldSize=_size;
ListNodePosi(T) p; ListNodePosi(T) q;//定义2个指针变量,依次指向紧邻的各对节点
for (p=header, q=header->succ; trailer!=q; p=q;q=q->succ)//自左向右扫描
if (p->data=q->data) {remove(q),q=p;}//若q和p相同,则删除q
return oldSize-_size;
}
二、查找
template <typename T>
//在有序列表内节点p的n个前驱中,找到不大于e的最后者
ListNodePosi(T) List<T>::search(T const &e, int n, ListNodePosi(T) p) const
{
while(0<n--) //对于p最近的n个前驱,从右向左逐个比较
if (((p=p->pred)->data)<=e) break;
//p=p->pred,使p指向p的前驱节点
//(p=p->pred)->data为前驱节点的data成员
return p;
}
2.2.5 排序器
与无序向量一样,针对无序列表任意合法区间的排序需求,设置一个统一的排序操作接口。
template <typename T>
void List<T>::sort(ListNodePosi(T) p, int n)
{
switch(rand()%3) //随机选择三种排序方法中的一种
{
case 1: insertionSort(p,n);break;//插入排序
case 2: selectionSort(p,n);break;//选择排序
default: mergeSort(p,n);break;//归并排序
}
}
一、插入排序
插入排序算法适用于包括向量与列表在内的任何序列结构,算法的思路可简要的描述为:始终将整个序列切分为2个部分,有序的前缀和无序的后缀。经过迭代,反复地将后缀元素的首地址转移到前缀中。如此,前缀范围不断扩展,直至覆盖整个序列。
template <typename T> //对起始于位置p的n个元素排序
void List<T>::insertSort(ListNodePosi(T) p,int n)
{
for (r=0;r<n;r++)
{
insertAfter(search(p->data,r,p),p->data);//查找适当的位置并插入,将p->data作为search(p->data,r,p)的后继插入,search(p->data,r,p)返回的是一个指针
p=p->succ; remove(p->pred);//转向下一节点
}
}
二、选择排序
将序列分为无序前缀和有序后缀2部分,每次只需从前缀中选出最大者,并作为最小元素转移至后缀中,即可使有序部分的范围不断扩张。算法的初始时刻,后缀为空,于是调用无序序列的查找算法,从前缀中找到最大者M。然后将M从前缀中取出并作为首元素插入后缀。