基本算法-双向链表反转

public class LinkedNode<T>{
    private T value;
    private LinkedNode<T> prev;
    private LinkedNode<T> next;    
    
    public LinkedNode(T value, LinkedNode<T> prev, LinkedNode<T> next) {
        super();
        this.value = value;
        this.prev = prev;
        this.next = next;
    }

    public T getValue() {
        return value;
    }
    public void setValue(T value) {
        this.value = value;
    }
    public LinkedNode<T> getPrev() {
        return prev;
    }

    public void setPrev(LinkedNode<T> prev) {
        this.prev = prev;
    }

    public LinkedNode<T> getNext() {
        return next;
    }
    public void setNext(LinkedNode<T> next) {
        this.next = next;
    }    
}
public class LinkedList<T>{
    private transient int size=0;
    private transient LinkedNode<T> first=null;
    private transient LinkedNode<T> last=null;
     public void addFirst(T t){
        LinkedNode<T> oldFirst = first;
        LinkedNode<T> newNode = new LinkedNode<T>(t,  null,oldFirst);
        first = newNode;
        if (oldFirst == null) {
            last = newNode;
        } else {
            oldFirst.setPrev(newNode);
        }
        size++;
    }
     
     /**
      * 
      * */
     public void reverse(){
         if(first==null||last==null) {
             return;
        }
         LinkedNode<T> prev;
         LinkedNode<T> next;
         LinkedNode<T> newFirst=null;
         LinkedNode<T> newLast=null;
         for (LinkedNode<T> node = first; node != null; node = node.getPrev()){
            prev= node.getPrev();
            next= node.getNext();

            if(node.getPrev()==null){
                newLast=node;
            }else if(node.getNext()==null){
                newFirst=node;
            } 
            node.setNext(prev);
            node.setPrev(next);                       
         }
         first=newFirst;
         last=newLast;
     }
}