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

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

✓ Brute Force (Convert to Array)

⏱️ Time: O(n log n) Space: O(n)

The most straightforward approach is to traverse the linked list and store all values in an array, then sort the array using any standard sorting algorithm, and finally reconstruct the linked list from the sorted array.

Two Pointers (Separate and Merge)

⏱️ Time: O(n) Space: O(1)

This approach recognizes that we can separate the linked list into two lists: one containing negative values and one containing positive values. Since the original list is sorted by absolute values, both resulting lists will be in the correct relative order within themselves.

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>
#include <string.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;
}

struct ListNode* parseInput(char* s) {
    // Remove whitespace
    while (*s == ' ') s++;
    
    if (strcmp(s, "[]") == 0 || strcmp(s, "[]\n") == 0) {
        return NULL;
    }
    
    // Skip '['
    s++;
    
    struct ListNode* head = NULL;
    struct ListNode* tail = NULL;
    
    char* token;
    char* rest = s;
    
    while (*rest && *rest != ']') {
        // Find next comma or ]
        char* end = rest;
        while (*end && *end != ',' && *end != ']') end++;
        
        // Extract number
        char temp = *end;
        *end = '\0';
        int val = atoi(rest);
        *end = temp;
        
        // Create node
        struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
        node->val = val;
        node->next = NULL;
        
        if (!head) {
            head = tail = node;
        } else {
            tail->next = node;
            tail = node;
        }
        
        // Move to next
        rest = end;
        if (*rest == ',') rest++;
    }
    
    return head;
}

void formatOutput(struct ListNode* head) {
    if (!head) {
        printf("[]");
        return;
    }
    
    printf("[");
    struct ListNode* current = head;
    int first = 1;
    while (current) {
        if (!first) printf(",");
        printf("%d", current->val);
        current = current->next;
        first = 0;
    }
    printf("]");
}

int main() {
    char input[10000];
    if (fgets(input, sizeof(input), stdin)) {
        // Remove newline
        input[strcspn(input, "\n")] = '\0';
        
        struct ListNode* head = parseInput(input);
        struct ListNode* result = sortList(head);
        formatOutput(result);
        printf("\n");
    }
    
    return 0;
}

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