Sort Linked List Already Sorted Using Absolute Values

Sort Linked List Already Sorted Using Absolute Values - Problem

You're given a singly linked list that has an interesting property: it's already sorted in non-decreasing order by the absolute values of its nodes. However, the actual values might be negative, making the list appear unsorted when considering the real values.

Your task is to sort this linked list by the actual values (not absolute values) while maintaining the non-decreasing order.

For example, if you have a list like [-5, -2, 3, 4, -6] which is sorted by absolute values [5, 2, 3, 4, 6], you need to rearrange it to [-6, -5, -2, 3, 4] sorted by actual values.

The key insight is that since the list is already sorted by absolute values, negative numbers with larger absolute values need to be moved to the front, while maintaining the relative order of positive numbers.

Input & Output

example_1.py — Basic Case

$ Input: head = [-5, -2, 3, 4, -6]

› Output: [-6, -5, -2, 3, 4]

💡 Note: The original list is sorted by absolute values: |5|, |2|, |3|, |4|, |6|. After sorting by actual values, negative numbers come first in descending order of their absolute values, followed by positive numbers.

example_2.py — Only Positive Values

$ Input: head = [1, 3, 5, 7, 9]

› Output: [1, 3, 5, 7, 9]

💡 Note: Since all values are positive, the list is already sorted by actual values and remains unchanged.

example_3.py — Only Negative Values

$ Input: head = [-1, -3, -5]

› Output: [-5, -3, -1]

💡 Note: All values are negative, so we need to reverse the order since the original was sorted by absolute values (1 < 3 < 5), but for actual values we need -5 < -3 < -1.

Constraints

The number of nodes in the list is in the range [0, 10⁴]
-10⁴ ≤ Node.val ≤ 10⁴
The list is sorted in non-decreasing order by absolute values
You must sort the list in non-decreasing order by actual values

Visualization

Tap to expand

Understanding the Visualization

Identify the Pattern

Original list is sorted by |value|: |-5|=5, |-2|=2, |3|=3, |4|=4, |-6|=6

Separate by Sign

Split into negative [-5, -2, -6] and positive [3, 4] sublists

Reverse Negatives

Reverse negative list to [-6, -5, -2] for correct ordering

Merge Lists

Connect reversed negative list to positive list: [-6, -5, -2, 3, 4]

Key Takeaway

🎯 Key Insight: Since the list is sorted by absolute values, we only need to handle the relative positioning of negative numbers (which should be reversed) and positive numbers (which are already correctly ordered).

Asked in

G Google 28 a Amazon 22 ⊞ Microsoft 18 f Meta 15

The optimal approach uses two pointers to separate negative and positive nodes in O(n) time. Since the list is sorted by absolute values, we can separate negative nodes, reverse their order (because larger absolute values should come first), and then connect them to the positive nodes which are already in correct order. This gives us O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Convert to Array)	O(n log n)	O(n)	Convert linked list to array, sort the array, then rebuild the linked list
Two Pointers (Separate and Merge)	O(n)	O(1)	Separate negative and positive nodes, then merge them back maintaining order

Brute Force (Convert to Array) — Algorithm Steps

Traverse the linked list and store all values in an array
Sort the array using a standard sorting algorithm like quicksort
Create a new linked list from the sorted array
Return the head of the new sorted linked list

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Values

Traverse linked list and copy values to array

Sort Array

Use standard sorting algorithm on the array

Rebuild List

Create new linked list nodes from sorted array

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

struct ListNode {
    int val;
    struct ListNode *next;
};

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

struct ListNode* sortList(struct ListNode* head) {
    if (!head) return NULL;
    
    // Count nodes
    int count = 0;
    struct ListNode* current = head;
    while (current) {
        count++;
        current = current->next;
    }
    
    // Convert to array
    int* values = (int*)malloc(count * sizeof(int));
    current = head;
    for (int i = 0; i < count; i++) {
        values[i] = current->val;
        current = current->next;
    }
    
    // Sort the array
    qsort(values, count, sizeof(int), compare);
    
    // Rebuild linked list
    struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    current = dummy;
    for (int i = 0; i < count; i++) {
        current->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        current->next->val = values[i];
        current->next->next = NULL;
        current = current->next;
    }
    
    struct ListNode* result = dummy->next;
    free(dummy);
    free(values);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Converting to array takes O(n), sorting takes O(n log n), rebuilding list takes O(n)

⚡ Linearithmic

Space Complexity

O(n)

Need extra space to store all values in an array

⚡ Linearithmic Space

42.3K Views

Medium Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Convert to Array) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler