linedlist是一种基于链表数据结构的一种java数据结构,我们先看看有哪些接口:
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
//...
}
List就不说了,和前面一样的接口。
我们看看Deque接口
void addFirst(E e);//从头插入
void addLast(E e);//从尾插入
boolean offerFirst(E e);
boolean offerLast(E e);
E removeFirst();
E removeLast();
E pollFirst();
E pollLast();
E getFirst();
E getLast();
E peekFirst();
E peekLast();
boolean removeFirstOccurrence(Object o);
boolean removeLastOccurrence(Object o);
boolean add(E e);
boolean offer(E e);
E remove();
E poll();
E element();
E peek();
boolean addAll(Collection<? extends E> c);
void push(E e);
E pop();
boolean remove(Object o);
boolean contains(Object o);
int size();
Iterator<E> iterator();
Iterator<E> descendingIterator();
这么一坨方法,看上去多的不行,实际上都是队列的头/尾插入、头/尾弹出,查看/包含,生成正序/反序迭代器的方法。
所以这个接口没什么好说的,唯一值得说的是:当我们想要使用一个Queue,实际上是new一个LinkedList对象来完成队列
的各种功能。
因为显然:
Queue继承Collection,Deque继承Queue(Deque是表示双端队列,从首尾均可以操作),LinkedList实现了Deque。
这么一看,就清晰明了了。
接下来是三个不能被Serializable的三个字段:
transient int size = 0;//节点数
transient Node<E> first;//头结点
transient Node<E> last;//尾结点
这也十分符合我们的预期。
首先,构造器如下:
public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
哇,和ArrayList十分复杂的三个构造器相比,实在是清晰许多嘛。
不带任何参数的初始化可以构造出size=0,first=last=null的链表。
如果带集合参数就调用addAll把所有的节点插进去(似乎一般人也是这么做的)。
下面,主角来了,节点的定义如下
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
可以看出节点还是一个私有静态类呢,然后里面再包含元素,前后两个指针。所以链表实质上是双端链表。
然后我们依然按照“增删改查”的顺序分析方法。
首先是“增”:
public boolean add(E e) {
linkLast(e);//调用linkLast方法表明从尾部链接一个节点
return true;
}
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);//前驱指针指向last
last = newNode;
if (l == null)//如果当时为空链表,首部也链接新节点
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
然后不可避免的是要增加modCount修改次数。
从前插入:
public void addFirst(E e) {
linkFirst(e);
}
private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);//后继指向头指针
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;//与头结点链接
size++;
modCount++;
}
几乎一模一样的操作,没什么可说的,就是指针操作稍有不同。
下面是addAll:
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
Node<E> pred, succ;
if (index == size) {
succ = null;
pred = last;
} else {
succ = node(index);
pred = succ.prev;
}
for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null)
first = newNode;
else
pred.next = newNode;
pred = newNode;
}
if (succ == null) {
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
还是没什么可说的,就是一个for循环链接起来一串链表,但是是在自己的方法里面addAll,并不是调用n次Add方法。
然后这里面有个node方法。实际上是一个寻找插入位置的算法。
Node<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
这个返回第index个节点的方法做了点优化:
如果下标小于节点数的一半,那么就从头搜索。
如果大于等于节点数的一半,那么就从尾搜索。
然后看看插入算法。
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
final Node<E> pred = succ.prev;
final Node<E> newNode = new Node<>(pred, e, succ);
succ.prev = newNode;
if (pred == null)
first = newNode;
else
pred.next = newNode;
size++;
modCount++;
}
其实真没啥可说的,就是如果插入点在末尾,就相当于addLast,否则,就是一个前插操作。
我要说的是:
不是说随机插入就是O(1)时间!!!
不是说随机插入就是O(1)时间!!!
不是说随机插入就是O(1)时间!!!
实际上搜索位置的node方法是需要O(n)时间的,已知节点引用,然后在这个基础上插入/删除才是常数时间,别被洗脑了。。。
然后,“删”,我决定把几个方法放在一起说:
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
private E unlinkLast(Node<E> l) {
// assert l == last && l != null;
final E element = l.item;
final Node<E> prev = l.prev;
l.item = null;
l.prev = null; // help GC
last = prev;
if (prev == null)
first = null;
else
prev.next = null;
size--;
modCount++;
return element;
}
public boolean remove(Object o) {
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
E unlink(Node<E> x) {
// assert x != null;
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
if (prev == null) {
first = next;
} else {
prev.next = next;
x.prev = null;
}
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
x.item = null;
size--;
modCount++;
return element;
}
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
总的来说吧,都是采用了搜索--删除方法来解除已经得到的链接。
而且依然要注意这里面使用了node方法,随机删除(不是头/尾)的时间依然是O(n)。
再看看查,为了方便起见,我们只看indexOf方法
public int indexOf(Object o) {
int index = 0;
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}
同理,LinkedList是可以放入null的,所以搜索元素的时候要分null或者是 非null 两种情况来处理,而且都是线性搜索的过程。
然后
public boolean removeFirstOccurrence(Object o)
public boolean removeLastOccurrence(Object o)
就是一个从头或从尾第一次发现的object。
剩下那些获取迭代器什么的就不说了。
看看如何实现序列化的:
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();//保存除了size和last,first四个指针的所有变量
// Write out size
s.writeInt(size);//保存size
// Write out all elements in the proper order.
for (Node<E> x = first; x != null; x = x.next)
s.writeObject(x.item);//把节点一个个的写到输出流
}
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();//加载对象除了size,last,first
// Read in size
int size = s.readInt();//读取长度
// Read in all elements in the proper order.
for (int i = 0; i < size; i++)
linkLast((E)s.readObject());//利用linkLast(相当于addLast,但是参数是一个节点)
//一个个的添加回来节点。
}
至此,已经结束LinkedList的分析,就是一个简单的双端链表而已。但是智慧的程序员们对其线性搜索进行了优化。