Sort a linked list after converting elements to their squares

 <script>

        // JavaScript Program to implement
        // the above approach 
        class Node {

            constructor(data) {
                this.data = data;
                this.next = null;
            }
        }

        // Utility function to make linked list
        function makeList(n, arr) {
            let h = null;
            let root;
            for (let i = 0; i < n; i++) {
                let data = arr[i];

                let node = new Node(data);

                if (h == null) {
                    h = node;
                    root = h;
                }
                else {
                    root.next = node;
                    root = node;
                }
            }
            return h;
        }

        // Utility function to print list
        function print_list(head) {
            while (head != null) {
                document.write(head.data + " ")
                head = head.next;
            }
            document.write("<br>")
        }

        // Function to reverse the linked list
        function reverse(head)
        {
        
            // Initialize current, previous and
            // next pointers
            let current = head;
            let prev = null, next = null;

            while (current != null) {
                // Store next
                next = current.next;

                // Reverse current node's pointer
                current.next = prev;

                // Move pointers one position ahead.
                prev = current;
                current = next;
            }
            head = prev;
            return head;
        }

        // This function will find the point of transition
        // where elements switch from negative to positive
        // and return that point
        function findBreakPoint(head) {
            if (head == null) {
                return null;
            }

            let prev = null, curr = head;

            while (curr != null) {
                prev = curr;
                curr = curr.next;

                if (curr != null) {
                    // If prev element is negative and
                    // current element is positive
                    if ((prev.data) < 0
                        && (curr.data) >= 0) {

                        return prev;
                    }
                }
            }

            // Checking if list contains
            // only negative elements
            curr = head;
            while (curr.next) {
                if (curr.data < 0) {
                    curr = curr.next;
                    continue;
                }
                else {
                    // Contains positive elements
                    return null;
                }
            }

            // Contains only negative element
            // so returning the last element of the list
            return curr;
        }

        // Utility function to merge two sorted lists
        function mergeUtil(h1,
            h2) {
            // If only one node in first list
            // simply point its head to second list
            if (!h1.next) {
                h1.next = h2;
                return h1;
            }

            // Initialize current and next pointers of
            // both lists
            let curr1 = h1, next1 = h1.next;
            let curr2 = h2, next2 = h2.next;

            while (next1 && curr2) {
                // If curr2 lies in between
                // curr1 and next1
                // then do curr1.curr2.next1
                if ((curr2.data) >= (curr1.data)
                    && (curr2.data) <= (next1.data)) {
                    next2 = curr2.next;
                    curr1.next = curr2;
                    curr2.next = next1;

                    // Let curr1 and curr2 to point
                    // their immediate next pointers
                    curr1 = curr2;
                    curr2 = next2;
                }
                else {
                    // If more nodes in first list
                    if (next1.next) {
                        next1 = next1.next;
                        curr1 = curr1.next;
                    }

                    // Else point the last
                    // node of first list
                    // to the remaining
                    // nodes of second list
                    else {
                        next1.next = curr2;
                        return h1;
                    }
                }
            }
            return h1;
        }

        // Merges two given lists in-place.
        // This function mainly compares
        // head nodes and calls mergeUtil()
        function merge(h1,
            h2) {
            if (!h1)
                return h2;
            if (!h2)
                return h1;

            // Start with the linked list
            // whose head data is the least
            if (h1.data < h2.data)
                return mergeUtil(h1, h2);
            else
                return mergeUtil(h2, h1);
        }

        // Function to return resultant squared list
        function squaresList(head) {
            if (head == null)
                return null;

            let mid = findBreakPoint(head);

            let temp = head;
            while (temp != null) {
                temp.data *= temp.data;
                temp = temp.next;
            }

            // List contains only positive elements
            if (mid == null) {
                return head;
            }

            // List contains both positive
            // and negative elements
            let h1 = head;
            let h2 = mid.next;

            // Breaking the list where negative
            // switches to positive
            mid.next = null;

            // Reversing the list
            h1 = reverse(h1);

            // Merging the two lists
            let ans = merge(h1, h2);

            return ans;
        }

        // Driver Program


        let n = 7;
        let arr1 = [1, 2, 3, 4, 5];
        let head = makeList(arr1.length, arr1);

        n = 6;
        let arr2 = [-2, -1, 0, 1, 2];
        head = makeList(arr2.length,
            arr2);

        let arr3 = [-5, -4, -3, -2, -1];
        head = makeList(arr3.length,
            arr3);
        print_list(squaresList(head));

    // This code is contributed by Potta Lokesh
    </script>