双链表反转，追加节点和删除节点

双链表反转，追加节点和删除节点。

Java版的一种实现如下：

public class DLinkedList<T extends Comparable<T>> {

    private DLinkedNode<T> head;
    private DLinkedNode<T> tail;


    public DLinkedList() {
    }

    //追加节点
    public void add(T t) {
        if (t == null) {
            return;
        }

        DLinkedNode curr = new DLinkedNode(t, null, null);
        if (tail == null) {
            head = curr;
            tail = curr;
            return;
        }

        tail.next = curr;
        curr.prev = tail;
        tail = curr;
    }

    //移除一个节点
    public boolean removeOne(T t) {
        if (t == null) {
            return true;
        }

        DLinkedNode p = head;
        if (p == null) {
            return false;
        }

        DLinkedNode u, v;
        while (p != null) {
            if (p.value.equals(t)) {
                u = p.prev;
                v = p.next;
                p.prev = null;
                p.next = null;

                if (u != null) {
                    u.next = v;
                } else {
                    head = v;
                }

                if (v != null) {
                    v.prev = u;
                } else {
                    tail = u;
                }

                return true;
            }
            p = p.next;
        }

        return false;
    }

    //双链表反转
    public void reverse() {
        if (head == null || head.next == null) {
            return;
        }

        DLinkedNode p, q;
        DLinkedNode newHead = null;
        DLinkedNode newTail = null;

        p = head;
        q = head.next;

        while (p != null) {
            p.prev = null;
            p.next = newHead;
            if (newHead != null) {
                newHead.prev = p;
            } else {
                newTail = p;
            }
            newHead = p;

            if (q != null) {
                p = q;
                q = q.next;
            } else {
                break;
            }
        }
        head = newHead;
        tail = newTail;
    }

}

class DLinkedNode<T extends Comparable<T>> {
    public T value;
    public DLinkedNode prev;
    public DLinkedNode next;

    public DLinkedNode() {
    }

    public DLinkedNode(T value, DLinkedNode prev, DLinkedNode next) {
        this.value = value;
        this.next = next;
        this.prev = prev;
    }
}