public class LinkedList_Sort
{
    class Listnode
    {
        int data;
        Listnode next;
        public Listnode(int data){
            this.data=data;
            this.next=null;
        }
    }
    public Listnode head = null;
    public Listnode tail = null;
    public void addNode(int data)
    {
        Listnode newNode = new Listnode(data);
        if(head==null)
        {
            head = newNode;
            tail = newNode;
        }
        else{
            tail.next = newNode;
            tail = newNode;
        }
    }
    public void sortList(){
        Listnode Current_node,nextNode;
        int temp;
        Current_node = head;
        nextNode = null;
        if(head == null)
        {
            return;
        }
        else{
            while(Current_node!=null)
            {
                nextNode = Current_node.next;
                while(nextNode!=null)
                {
                    if(Current_node.data > nextNode.data)
                    {
                        temp = Current_node.data;
                        Current_node.data = nextNode.data;
                        nextNode.data = temp;
                    }
                    nextNode = nextNode.next;
                }
                Current_node = Current_node.next;
            }
        }
    }
    public void display(){
        Listnode Current_node = head;
        if(head == null)
        {
            System.out.println("Linked List is Empty");
            return;
        }
        while(Current_node != null)
        {
            System.out.println("\\n Linked list element is : "+Current_node.data);
            Current_node = Current_node.next;
        }
    }
	public static void main(String[] args) {
	    LinkedList_Sort l = new LinkedList_Sort();
	    l.addNode(10);
	    l.addNode(4);
	    l.addNode(7);
	    l.addNode(2);
	    System.out.println("\\n List before sorted array");
	    l.display();
	    System.out.println("\\n List after sorted array");
	    l.sortList();
	    l.display();
	}
}

                          // Linked List sort using QuickSort
public class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

public ListNode sortList(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    
    ListNode pivot = head;
    ListNode lessHead = new ListNode(0);
    ListNode less = lessHead;
    ListNode equalHead = new ListNode(0);
    ListNode equal = equalHead;
    ListNode greaterHead = new ListNode(0);
    ListNode greater = greaterHead;
    
    while (head != null) {
        if (head.val < pivot.val) {
            less.next = head;
            less = less.next;
        } else if (head.val == pivot.val) {
            equal.next = head;
            equal = equal.next;
        } else {
            greater.next = head;
            greater = greater.next;
        }
        head = head.next;
    }
    less.next = null;
    equal.next = null;
    greater.next = null;
    
    ListNode sortedLess = sortList(lessHead.next);
    ListNode sortedGreater = sortList(greaterHead.next);
    
    return concat(sortedLess, equalHead.next, sortedGreater);
}

private ListNode concat(ListNode head1, ListNode head2, ListNode head3) {
    ListNode dummy = new ListNode(0);
    ListNode tail = dummy;
    tail.next = head1;
    while (tail.next != null) {
        tail = tail.next;
    }
    tail.next = head2;
    while (tail.next != null) {
        tail = tail.next;
    }
    tail.next = head3;
    return dummy.next;
}

ListNode head = ... // initialize the linked list
ListNode sortedHead = sortList(head);