概念

• 与向量(Vector)的循秩访问(call-by-rank)不同的是列表采用的是循位置访问(call-by-position)
• 列表采用的是动态存储机制,通过引用或指针来确定元素的实际物理地址

无序列表实现

1.类型声明

public class ListNode<T> {
public T data;
public ListNode pred;//前继
public ListNode succ;//后继
public ListNode(){
}
public ListNode(T e,ListNode p,ListNode s){
this.pred=p;
this.succ=s;
this.data=e;
ListNode insertAsdpred(T e);
ListNode insertAsSucc(T e);
}
public class List<T>{
private int size;
private ListNode <T>header;//头哨兵
private ListNode<T>trailer;//尾哨兵
public List(){
header=new ListNode<T>();
trailer=new ListNode<T>();
header.succ=trailer;
header.pred=null;
trailer.succ=null;
trailer.pred=header;
size=0;
}

2.查找接口
//在结点p之前的n个前驱中,找到等于e的最后者

ListNode find(T e,int n,ListNode p){
while(n--){
if(e==(p=p.pred).data){
return p;
return null;
}

复杂度是O(n)
3.前插入
//新元素e作为当前节点的前驱插至列表

ListNode insertAsPred(T e){
ListNode x=new ListNode(e,this.pred,this);
this.pred.succ=x;
x.succ=this;
return x;
}

4.后插入
//新元素e作为当前节点的后继插至列表

ListNode insertAsSucc(T e){
ListNode x=new ListNode(e,this,this.succ);
this.succ.pred=x;
this.succ=x;
return x;
}

5.删除操作
//删除指定节点p

T remove(ListNode p){
p.pred.succ=p.succ;
p.succ.pred=p.pred;
return p.data;
size--;
}

6.析构操作

int clear(){
int oldsize=size;
while(size>0){
remove(header.succ);
}
return oldsize;
}

7.唯一化
//剔除无序列表中重复元素,返回被删除元素数量

int deduplicate(){
int oldsize=size;
if(size<2){
return 0;
}
ListNode p=header;//从头哨兵开始
rank r=0;
while(trailer!=(p=p.succ)){
ListNode q=find(p.data,r,p);
q ? remove(q):r++);
}
return  oldsize-size;
}

复杂度O(n^2)

有序列表的实现

1.唯一化

int uniquify(){
int oldsize=size;
if(size<2){
return 0;
}
ListNode p,q;//依次指向紧邻的各对节点
for(p=header,q=p.succ;trailer != q; p = q, q = q->succ){
if (p->data == q->data)
 { 
remove(q);
 q = p; 
} 
return oldsize-size;
}

2.查找
//在节点p的n个前驱中，找到不大于e的最后者

ListNode search(T e,int n,ListNode p){
while(0<n--){
if((p=p.pred).data<=e)
break;
return p;
}