[Java] Dubbellänkad lista, sorteringsproblem

/**
* Klassen "Node" skapar och hanterar noder för användning i länkade listor.
*
* @version 0.1
*/
public class Node{
	/**
	* Konstruerar en Node utan referenser och värde.
	*/
	public Node(){}
	/**
	* Konstruerar en Node utan referenser med valt värde
	*
	* @param _i Nodens värde
	*/
	public Node(int _i){
		i = _i;
	}
	/**
	* Konstruerar en Node med referens bakåt och framåt samt valt värde
	*
	* @param _i Nodens värde
	* @param _next Nodens referens framåt
	* @param _prev Nodens referens bakåt
	*/
	public Node(int _i, Node _next, Node _prev){
		i = _i;
		next = _next;
		prev = _prev;
	}

	int i;
	Node next;
	Node prev;
	/**
	* Tilldelar noden specifierat värde
	*
	* @param _i Specifierat värde
	*/
	public void setValue(int _i){
		i = _i;
	}
	/**
	* Tilldelar noden en referens framåt
	*
	* @param _next Referens framåt
	*/
	public void setNext(Node _next){
		next = _next;
	}
	/**
	* Tilldelar noden en referent bakåt
	*
	* @param _prev Referens bakåt
	*/
	public void setPrev(Node _prev){
		prev = _prev;
	}
	/**
	* Returnerar nodens värde
	*
	* @return nodens värde
	*/
	public int getValue(){
		return i;
	}
	/**
	* Returnerar nodens referens framåt
	*
	* @return referens framåt
	*/
	public Node getNext(){
		return next;
	}
	/**
	* Returnerar nodens referens bakåt
	*
	* @return referens bakåt
	*/
	public Node getPrev(){
		return prev;
	}

	public String toString(){
		String s = "Värde: "+i;

		return s;
	}
}
/*********************************************/
/*********************************************/
/**
* Klassen "DoubleLinked" skapar och hanterar dubbellänkade listor ihop med klassen "Node".
*
* @version 0.1
*/
public class DoubleLinked{

	Node n;
	Node first;
	Node last;

	public DoubleLinked(){}

	public void addFirst(Node _n){
		if(first==null){
			first = _n;
			last = _n;
			_n.setPrev(null);
			_n.setNext(null);
		}
		else{
			_n.setPrev(null);
			_n.setNext(first);
			first.setPrev(_n);
			first = _n;
		}
	}

	public void addLast(Node _n){
		if(last==null){
			addFirst(_n);
		}
		else{
			_n.setNext(null);
			_n.setPrev(last);
			last.setNext(_n);
			last = _n;
		}
	}


	//_nP, _nN can be null
	public void addBetween(Node _n, Node _nP, Node _nN){
		_n.setNext(_nN);
		_n.setPrev(_nP);
		if(_nN == null) last = _n;
		else _nN.setPrev(_n);
		if(_nP == null) first = _n;
		else _nP.setNext(_n);

	}
	public void remove(Node _n){
		if(_n.getNext() == null){
			_n.getPrev().setNext(null);
			last = _n.getPrev();
		}
		else if(_n.getPrev() == null){
			_n.getNext().setPrev(null);
			first = _n.getNext();
		}
		else{
		_n.getNext().setPrev(_n.getPrev());
		_n.getPrev().setNext(_n.getNext());
		_n = null;
		}
	}

	public Node getWithValue(int _i){
		n = first;
		while(n.getNext() != null){
			if(n.getValue() == _i){
				return n;
			}
			else{
				n=n.getNext();
			}
		}
		return null;
	}


	public Node getLast(){
		return last;
	}
	public Node getFirst(){
		return first;
	}

	public void sortDes(){
		boolean sorted = false;
		while(!sorted){
			sorted = true;
			for(Node cur=first;cur.getNext()!=null;cur=cur.getNext()){
				if(cur.getValue() < cur.getNext().getValue()){
					addBetween(cur, cur.getNext(), cur.getNext().getNext());
					sorted = false;
				}
			}
		}
	}

	public String toString(){
		StringBuilder result = new StringBuilder();
		n = first;
		while(n != null){
			result.append(n+"\n");
			n = n.getNext();
		}

		return result.toString();
	}
}

			for(Node cur=first;cur.getNext()!=null;cur=cur.getNext()){

import java.util.*;

public class Linking{
	public static void main(String[] args){
		boolean prog = true;
		Scanner scan = new Scanner(System.in);
		DoubleLinked list = new DoubleLinked();
		while(prog){
			System.out.println("Tryck\n1.Lägg heltal först i lista\n2.Lägg heltal sist i lista\n3.Skriv ut lista\n4.Sortera lista\n5.Ta bort tal ifrån lista\n0.Avsluta programmet\n");
			String s = scan.next();
			if(s.equals(""+1)){
				System.out.println("Skriv heltal separerade med radbrytning eller mellanslag\nSkriv END för att avsluta");
				boolean addfirst = true;
				while(addfirst){
					s = scan.next();
					if(s.equals("END")){
						addfirst = false;
					}
					else{
						list.addFirst(new Node(Integer.parseInt(s)));
					}
				}
			}
			else if(s.equals(""+2)){
				System.out.println("Skriv heltal separerade med radbrytning eller mellanslag\nSkriv END för att avsluta");
				boolean addlast = true;
				while(addlast){
					s = scan.next();
					if(s.equals("END")){
						addlast = false;
					}
					else{
						list.addLast(new Node(Integer.parseInt(s)));
					}
				}

			}
			else if(s.equals(""+3)){
				System.out.println(list);
			}
			else if(s.equals(""+4)){
				list.sortDes();
				System.out.println(list);
			}
			else if(s.equals(""+5)){
				System.out.println(list+"\nVilket värde ska tas bort?");
				int i = scan.nextInt();
				list.remove(list.getWithValue(i));
				System.out.println(list);
			}
			else if(s.equals(""+0)){
				break;
			}
			else{
				System.out.println("Var god försök igen.");
			}
		}
	}
}