文章标题

package com.ssh.test;

public class DoubleLinkedList {
// 节点类Node

private static class Node {
    Object value;
    Node prev = this;
    Node next = this;

    Node(Object v) {
        value = v;
    }

    public String toString() {
        return value.toString();
    }
}

private Node head = new Node(null); // 头节点
private int size; // 链表大小

// 以下是接口方法

// 添加到链表表头
public boolean addFirst(Object o) {
    addAfter(new Node(o), head);
    return true;
}

// 将元素添加到链表表尾
public boolean addLast(Object o) {
    addBefore(new Node(o), head);
    return true;
}

public boolean add(Object o) {
    return addLast(o);
}

// 将元素添加到指定位置
public boolean add(int index, Object o) {
    addBefore(new Node(o), getNode(index));
    return true;
}

// 移除指定位置
public boolean remove(int index) {
    removeNode(getNode(index));
    return true;
}

// 移除链表表头元素
public boolean removeFirst() {
    removeNode(head.next);
    return true;
}

// 移除链表表尾元素
public boolean removeLast() {
    removeNode(head.prev);
    return true;
}

// 取到指定位置的元素值
public Object get(int index) {
    return getNode(index).value;
}

// 返回链表的大小
public int size() {
    return size;
}

public String toString() {
    StringBuffer s = new StringBuffer("[");
    Node node = head;
    for (int i = 0; i < size; i++) {
        node = node.next;
        if (i > 0)
            s.append(", ");
        s.append(node.value);
    }
    s.append("]");
    return s.toString();
}

// 以下是实现方法

// 查找链表元素
private Node getNode(int index) {
    if (index < 0 || index >= size)
        throw new IndexOutOfBoundsException();
    Node node = head.next;
    for (int i = 0; i < index; i++)
        node = node.next;
    return node;
}

// 在某元素之前添加元素
private void addBefore(Node newNode, Node node) {
    newNode.prev = node.prev;
    newNode.next = node;
    newNode.next.prev = newNode;
    newNode.prev.next = newNode;
    size++;
}

// 在某元素之后添加元素
private void addAfter(Node newNode, Node node) {
    newNode.prev = node;
    newNode.next = node.next;
    newNode.next.prev = newNode;
    newNode.prev.next = newNode;
    size++;
}

// 移除特定元素
private void removeNode(Node node) {
    node.next.prev = node.prev;
    node.prev.next = node.next;
    node.prev = null;
    node.next = null;
    size--;
}

}
// 有些地方还可以优化，比如查找时可以判断索引是否大于size的一半，如果是的话，就从另一头开始迭代。