双向循环链表

package com.datastructure.List;

import java.util.Collection;
import java.util.NoSuchElementException;

/**
* 当前类为双向循环链表 该链表各元素类型可以不相同，不可反序列化
*
* @author LEIQIAO
*
* @param <E>
*/
public class LinkedList<E> {
private transient Entry<E> header = new Entry<E>(null, null, null);
private transient int size = 0;

public static void main(String[] args) {
LinkedList<Integer> link = new LinkedList<Integer>();
// 测试getFirst（）， removeFirst（）， addFirst（）；
// System.out.println(link.getFirst());
link.addFirst(1);
link.addFirst(2);
System.out.println(link.getFirst());
link.listAll();

}

/**
* Constructs an empty list.
*/
public LinkedList() {
header.next = header.previous = header;
}

/**
* 放回当前链表的第一元素
*
* @return 链表的第一个元素
* @throws NoSuchElementException
*             如果当前链表为空
*/
public E getFirst() {
if (size == 0)
throw new NoSuchElementException();

return header.next.element;
}

/**
* 返回当前链表的最后一个元素
*
* @return 最后一个元素
* @throws NoSuchElementException
*             如果当前链表为空
*/
public E getLast() {
if (size == 0)
throw new NoSuchElementException();

return header.previous.element;
}

/**
* 移除同时返回当前链表的第一个元素
*
* @return 链表的第一个元素
* @throws NoSuchElementException
*             链表为空
*/
public E removeFirst() {
return remove(header.next);
}

/**
* 移除且返回当前链表的最后一个元素
*
* @return the last element from this list
* @throws NoSuchElementException
*             if this list is empty
*/
public E removeLast() {
return remove(header.previous);
}

/**
* 添加当前链表的首元素
*
* @param 元素的数据
*/
public void addFirst(E e) {
addBefore(e, header.next);
}

/**
* 添加最后一个元素
*
* @param 元素的数据
*/
public void addLast(E e) {
addBefore(e, header);
}

/**
* 返回链表的长度
*
* @return 链表元素的数量
*/
public int size() {
return size;
}

/**
* 移除该链表的第一个该元素 链表元素允许为空，空则允许删除
*
* @param 链表中需要移除的元素
* @return 如果该链表中包含元素则返回true
*/
public boolean remove(Object o) {
if (o == null) {
for (Entry<E> e = header.next; e != header; e = e.next) {
if (e.element == null) {
remove(e);
return true;
}
}
} else {
for (Entry<E> e = header.next; e != header; e = e.next) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
}

/**
* 从特定位置把该集合所有元素插入到链表中.
*
* @param index 讲集合中第一个元素插入链表的位置
* @param c 包含插入链表元素的集合
* @return 链表改变返回真
* @throws IndexOutOfBoundsException
*             {@inheritDoc}
* @throws NullPointerException
*             if the specified collection is null
*/
public boolean addAll(int index, Collection<? extends E> c) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
+ size);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;

Entry<E> successor = (index == size ? header : entry(index));
Entry<E> predecessor = successor.previous;
for (int i = 0; i < numNew; i++) {
Entry<E> e = new Entry<E>((E) a[i], successor, predecessor);
predecessor.next = e;
predecessor = e;
}
successor.previous = predecessor;

size += numNew;
return true;
}

/**
* 返回索引位置的Entry<E> 索引位置从0开始，size表示元素的个数，即第size个为头结点
*/
private Entry<E> entry(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
+ size);

Entry<E> e = header;
// 双向循环链表：前半部分顺时针查找，后半部分逆时针查找
if (index < (size >> 1)) {
for (int i = 0; i <= index; i++)
e = e.next;
} else {
for (int i = size; i > index; i--)
e = e.previous;
}
return e;
}

private E remove(Entry<E> e) {
// 此处不可用size判断，因为头结点为算法的需要，规范操作，不可删除
if (e == header)
throw new NoSuchElementException();

E result = e.element;
e.previous.next = e.next;
e.next.previous = e.previous;
size--;
return result;
}

private Entry<E> addBefore(E e, Entry<E> entry) {
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
// newEntry.prrvious = entry.previous
entry.previous.next = newEntry;
// newEntry.next = entry
entry.previous = newEntry;
size++;
return newEntry;
}

public void listAll() {
for (Entry<E> p = header.next; p != header; p = p.next) {
System.out.println(p.element);
}
}

private static class Entry<E> {
E element;
Entry<E> next;
Entry<E> previous;

Entry(E element, Entry<E> next, Entry<E> previous) {
this.element = element;
this.next = next;
this.previous = previous;
}
}
}