链表：自定义双链表总结

双链表每个节点都有两个链prev和 next，所以相对于单链表在某些功能的实现上更简单一些。

Java实现

import java.util.Iterator;
import java.util.NoSuchElementException;

public class DoubleLinkedList<Item> implements Iterable<Item> {
    private class Node {
        private Item item;
        private Node prev;
        private Node next;
    }

    private Node first;
    private Node last;
    private int N;

    public DoubleLinkedList() {
        first = null;
        last = null;
    }

    public DoubleLinkedList(Item[] a) {
        for (Item i : a)
            append(i);
    }

    public DoubleLinkedList(Iterable<Item> coll) {
        for (Item i : coll)
            append(i);
    }

    public int size() {
        return N;
    }

    public boolean isEmpty() {
        return size() == 0;
    }

    /**
     * 返回头尾节点元素
     * 
     * @return
     */
    public Item first() {
        if (isEmpty())
            throw new RuntimeException("链表为空");
        return first.item;
    }

    public Item last() {
        if (isEmpty())
            throw new RuntimeException("链表为空");
        return last.item;
    }

    /**
     * 获取k位置的节点
     */
    public Node node(int k) {
        Node curr = null;
        int i = 1;
        if (k > 0) {
            curr = first;
            while (i < k && curr != null) {
                curr = curr.next;
                i++;
            }
        } else if (k < 0) {
            k = -k;
            curr = first;
            while (i < k && curr != null) {
                curr = curr.prev;
                i++;
            }
        }
        return curr;
    }

    /**
     * 头增
     */
    public void prepend(Item item) {
        Node x = new Node();
        x.item = item;
        if (isEmpty()) {
            first = x;
            last = x;
        } else {
            x.next = first;
            first.prev = x;
            first = x;
        }
        N++;
    }

    /**
     * 尾增
     */
    public void append(Item item) {
        Node x = new Node();
        x.item = item;
        if (isEmpty()) {
            first = x;
            last = x;
        } else {
            x.prev = last;
            last.next = x;
            last = x;
            N++;
        }
    }

    /**
     * 前插
     */
    public void insertBefore(Node node, Item item) {
        if (node == first)
            prepend(item);
        else {
            Node prev = node.prev;
            Node x = new Node();
            x.item = item;
            x.prev = prev;
            x.next = node;
            prev.next = x;
            node.prev = x;
            N++;
        }
    }

    /**
     * 后插
     */
    public void insertAfter(Node node, Item item) {
        if (node == last)
            append(item);
        else {
            Node next = node.next;
            Node x = new Node();
            x.item = item;
            x.prev = node;
            x.next = next;
            node.next = x;
            next.prev = x;
            N++;
        }
    }

    /**
     * 删除第一个元素
     */
    public Item removeFirst() {
        if (isEmpty())
            throw new RuntimeException("表为空");
        Item item = first.item;
        if (first.next != null)
            first.next.prev = null;
        first = first.next;
        N--;
        if (first == null)
            last = null; // 避免游离
        return item;
    }

    /**
     * 删除最后一个元素
     */
    public Item removeLast() {
        if (isEmpty())
            throw new RuntimeException("表为空");
        Item item = last.item;
        if (last.prev != null)
            last.prev.next = null;
        last = last.prev;
        N--;
        if (last == null)
            first = null;
        return item;
    }

    /**
     * 删除某个节点
     */
    public Item remove(Node node) {
        if (node == first)
            return removeFirst();
        else if (node == last)
            return removeLast();
        else {
            Node prev = node.prev;
            Node next = node.next;
            prev.next = node.next;
            next.prev = node.prev;
            N--;
            return node.item;
        }
    }
    /**
     * 迭代器
     */
    @Override
    public Iterator<Item> iterator() {
        return new ListIterator();
    }
    private class ListIterator implements Iterator<Item>{
        private Node current = first;

        @Override
        public boolean hasNext() {
            return current != null;
        }

        @Override
        public Item next() {
            if(!hasNext())
                throw new NoSuchElementException();
            Item item = current.item;
            current = current.next;
            return item;
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }   
    }
}