Lists
1. IntLists
下面我们来一步一步的实现List类,首先你可以实现一个最简单的版本:
public class IntList {
public int first;
public IntList rest;
public IntList(int f, IntList r) {
first = f;
rest = r;
}
}
这样一个链表看起来特别丑陋,比如,我们要生成一个拥有5,10,15三个整数的链表,不得不这么做:
IntList L = new IntList(5, null);
L.rest = new IntList(10, null);
L.rest.rest = new IntList(15, null);
或者时这样:
IntList L = new IntList(15, null);
L = new IntList(10, L);
L = new IntList(5, L);
尽管看起来丑陋,使用起来也十分困难,不过我们还是要为它添加几个方法,首先是size方法:
/** Return the size of the list using... recursion! */
public int size() {
if (rest == null) {
return 1;
}
return 1 + this.rest.size();
}
/** Return the size of the list using no recursion! */
public int iterativeSize() {
IntList p = this;
int totalSize = 0;
while (p != null) {
totalSize += 1;
p = p.rest;
}
return totalSize;
}
随后的几个方法在Lab 2(Lab 2同时教了debug)中呈现,先是讲解方法分为Destructive和Non-Destructive,也就是是否改变参数的值。然后讲义部分给出了将一个链表所有数值平方的三种实现,分别使用了Destructive版本、Non-Destructive迭代版本和Non-Destructive递归版本(实现代码),然后让学生自己实现链表拼接的Destructive版本和Non-Destructive版本,下面是我的实现:
/**
* Returns a list consisting of the elements of A followed by the
* * elements of B. May modify items of A. Don't use 'new'.
*/
public static IntList dcatenate(IntList A, IntList B) {
//TODO: fill in method
IntList res = A;
while (A.rest != null) {
A = A.rest;
}
A.rest = B;
return res;
}
/**
* Returns a list consisting of the elements of A followed by the
* * elements of B. May NOT modify items of A. Use 'new'.
*/
public static IntList catenate(IntList A, IntList B) {
//TODO: fill in method
IntList res = new IntList(A.first, null);
IntList ptr = res;
A = A.rest;
while (A != null) {
ptr.rest = new IntList(A.first, null);
ptr = ptr.rest;
A = A.rest;
}
ptr.rest = B;
return res;
}
2. SLLists
理论上讲,IntList可以实现一个链表能够做的所有事,不过它难以使用,代码难以理解。最主要的是,如果一个程序员想使用它,就必须了解它复杂的递归思想,要手动写出next的指向,这会大大降低这种数据结构的使用率。
所以,在原有IntList的基础上,我们设计一种新的类SLLists(Single Linked Lists),并为它提供一系列的方法。
首先我们创建一个新的类IntNode:
public class IntNode {
public int item;
public IntNode next;
public IntNode(int i, IntNode n) {
item = i;
next = n;
}
}
除了名字不同以外,它好像和IntList没有任何区别,没错,我们还需要创建另外一个类SLList:
public class SLList {
public IntNode first;
public SLList(int x) {
first = new IntNode(x, null);
}
}
它将IntNode进行了封装,会使用者提供了更简洁的使用方法,当使用IntList和SLList时,你可以清楚的看出SLList优秀的地方:
IntList L1 = new IntList(5, null);
SLList L2 = new SLList(5);
SLList隐藏了IntNode中靠next取得的联系,使用者不必关心SLList内部如何实现,只知道如何用它来存储数据就足够了。我们再为SLList添加几个方法:
public class SLList {
public IntNode first;
public SLList(int x) {
first = new IntNode(x, null);
}
/** Adds an item to the front of the list. */
public void addFirst(int x) {
first = new IntNode(x, first);
}
/** Retrieves the front item from the list. */
public int getFirst() {
return first.item;
}
}
通过比较,你会发现SLList使用起来更简单了:
SLList L = new SLList(15);
L.addFirst(10);
L.addFirst(5);
int x = L.getFirst();
IntList L = new IntList(15, null);
L = new IntList(10, L);
L = new IntList(5, L);
int x = L.first;
再来比较一下它们的内部实现:
不过,如果使用者这样使用呢?
SLList L = new SLList(15);
L.addFirst(10);
L.first.next.next = L.first.next;
这将会导致死循环,所以我们要把first声明为私有变量,禁止使用者调用它,这样,上面的操作将会报错。不过这时,我们有两个.java
文件,使用者每次使用都要导入这两个文件,所以,我们可以将IntNode写入SLList类
中,这也称为Nested Classes。并且IntNode不会调用它以外的SLList中的值,所以我们把它声明为static类型
,实现如下:
public class SLList {
public static class IntNode {
public int item;
public IntNode next;
public IntNode(int i, IntNode n) {
item = i;
next = n;
}
}
private IntNode first;
...
我们再为它添加size
方法:
/** Returns the size of the list starting at IntNode p. */
private static int size(IntNode p) {
if (p.next == null) {
return 1;
}
return 1 + size(p.next);
}
public int size() {
return size(first);
}
然而,size方法内部使用了递归或者迭代,如果长度为1000的链表的size需要耗时2秒,那么计算长度为1,000,000的链表的size就可能会耗时2000秒。所以我们要将size方法的时间复杂度设计为常数,这里用到了储存
(caching)的思想,我们添加一个size变量
,并时刻跟踪改变它的值:
public class SLList {
... /* IntNode declaration omitted. */
private IntNode first;
private int size;
public SLList(int x) {
first = new IntNode(x, null);
size = 1;
}
public void addFirst(int x) {
first = new IntNode(x, first);
size += 1;
}
public int size() {
return size;
}
...
}
这样,无论链表多么长,size方法都会很快的返回它的值。下面我们再仔细思考,如果一个链表为空,我们如何表示它?一种方法是为它设计空参构造函数:
public SLList() {
first = null;
size = 0;
}
不过它的addLst方法将变得很庞大,而且之后每添加一个类似的方法,我们都需要考虑链表为空
的情况。
public void addLast(int x) {
size += 1;
if (first == null) {
first = new IntNode(x, null);
return;
}
IntNode p = first;
while (p.next != null) {
p = p.next;
}
p.next = new IntNode(x, null);
}
所以,在设计伊始,我们设计的模型要在根本上解决这个问题。这里的设计思想一开始可能会难以接受,不过渐渐你会发现它的优秀之处。我们采取的手段是添加一个空的node节点
,称之为sentinel node。
于是,当我们通过SLList L = new SLList()
实例化一个SLList对象时,它的内部将会变成这样:
当为链表添加5,10,15三个元素时,它将变成这样:
这样,addLast方法就变得简洁易读多了。
public void addLast(int x) {
size += 1;
IntNode p = sentinel;
while (p.next != null) {
p = p.next;
}
p.next = new IntNode(x, null);
}
但是,addLst方法同样存在一个问题,就是链表的长度越长,它的执行时间也就越长。为了解决这一问题,我们同样可以使用储存的思想,为它添加一个last变量,时刻记录尾节点的位置。
public class SLList {
private IntNode sentinel;
private IntNode last;
private int size;
public void addLast(int x) {
last.next = new IntNode(x, null);
last = last.next;
size += 1;
}
...
}
它的内部就变成了下面这样:
再考虑,如果我们要添加一个移除最后一个元素
的removeLast方法,该如何实现?大致的思路就是获取到倒数第二个节点
,然后将倒数第二个节点的next设为null,可是,如何获取到倒数第二个节点呢?
从sentinel向后遍历是不可能的了,那将使方法具有线性复杂度,其实,在现有的模型结构下很难实现,所以,我们不得在现有模型的基础上再次设计一种新的数据结构,也就是下面的DLList
。
3. DLLists
这一次的改造更加彻底,我们在每一个IntNode中添加一个prev变量
,也就是为整个链表添加了Back pointers
:
public class IntNode {
public IntNode prev;
public int item;
public IntNode next;
}
之所以称之为DLList,其实是Doubly linked list,也就是双向链表
,空链表和非空链表的内部结构如下所示:
目前,我们设计的DLList已经可以在头部和尾部进行快速的添加、获取和删除操作,唯一不足的地方就是last
指针有时指向带有数据的节点,有时指向sentinel这种特殊的空接点,在以后的实现中可能会造成混乱。
所以,我们可以用以下两种方法来避免:
-
一种是在尾部增加一个sentinel空结点。
-
一种是采用
circle
的的思想,让首尾指针指向同一个sentinel空结点。
这两种设计思想都很完美,在这里,cs61b让学生自己实现这种数据结构,并添加一定的方法,而且需要设计成泛型,也就是Project 1A的第一部分。
我采取的第二种实现版本,这里是我的实现,上一个目录有说明文件。
至此,我们已经设计并实现了一种健壮实用易扩展的数据结构,更重要的是在设计过程中发现问题、解决问题的设计思想。底层实现过程和设计思想
,这也是cs61b最重视的部分。