Relative Sort Array - Practice Coding Problems

Relative Sort Array - Problem

Imagine you have two arrays: arr1 contains a mixed collection of numbers, while arr2 serves as a priority template that defines the desired ordering.

Your mission is to rearrange arr1 so that:

Elements that appear in arr2 come first, in the exact same relative order as they appear in arr2
Elements that don't appear in arr2 are placed at the end in ascending order

Think of arr2 as a VIP list - those numbers get priority placement, while the rest are sorted normally at the back of the line!

Example: If arr1 = [2,3,1,3,2,4,6,7,9,2,19] and arr2 = [2,1,4,3,9,6], the result should be [2,2,2,1,4,3,3,9,6,7,19].

Input & Output

example_1.py — Basic Case

$ Input: arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]

› Output: [2,2,2,1,4,3,3,9,6,7,19]

💡 Note: Elements 2,1,4,3,9,6 appear first in the order specified by arr2. Each appears with its original frequency from arr1. Elements 7,19 don't appear in arr2, so they're sorted and placed at the end.

example_2.py — All Elements in arr2

$ Input: arr1 = [28,6,22,8,44,17], arr2 = [22,28,8,6]

› Output: [22,28,8,6,17,44]

💡 Note: Most elements follow arr2 order: 22,28,8,6. Elements 17,44 are not in arr2, so they're sorted (17 < 44) and appended at the end.

example_3.py — Edge Case with Duplicates

$ Input: arr1 = [1,1,1], arr2 = [1]

› Output: [1,1,1]

💡 Note: All elements in arr1 are 1, and 1 appears in arr2. So all three 1's are placed first, maintaining the relative order defined by arr2.

Constraints

1 ≤ arr1.length, arr2.length ≤ 1000
0 ≤ arr1[i], arr2[i] ≤ 1000
All elements in arr2 are distinct
Each element in arr2 is also in arr1

Visualization

Tap to expand

Understanding the Visualization

Count All Attendees

Count how many tickets each person bought (frequency counting)

Seat VIPs First

Follow the VIP priority list order, seating all instances of each VIP

Sort General Admission

Arrange remaining attendees alphabetically (or numerically)

Final Seating Chart

VIPs in priority order, followed by sorted general admission

Key Takeaway

🎯 Key Insight: By treating arr2 indices as priority values and using counting sort principles, we achieve optimal performance while maintaining both priority ordering and sorted arrangement for non-priority elements.

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal approach uses a counting sort technique combined with priority mapping. We count the frequency of each element in arr1, then reconstruct the result by following arr2's order for priority elements and sorting the remaining elements. This achieves O(n + m + k log k) time complexity, where k is the number of non-priority elements.

Common Approaches

Approach	Time	Space	Notes
✓ Counting Sort (Optimal)	O(n + m + k log k)	O(n + m)	Use counting technique with priority positions for optimal O(n+m) solution
Two-Pass Hash Table	O(n + m + k log k)	O(m + n)	Build position map from arr2, then process arr1 in one pass using the map
Brute Force (Nested Loops)	O(n × m + k log k)	O(n)	For each element in arr2, scan arr1 multiple times to collect matching elements

Counting Sort (Optimal) — Algorithm Steps

Count frequency of each element in arr1
Create priority map from arr2 with index positions
Build result by iterating through arr2 and adding counted elements
Collect remaining elements not in arr2 and sort them
Append sorted remaining elements to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count how many times each element appears in arr1

Process Priority Order

Follow arr2 order and add elements with their counts

Handle Remaining

Collect remaining elements and sort them

Combine Results

Merge priority elements with sorted remaining

Code -

solution.c — C

int* relativeSortArray(int* arr1, int arr1Size, int* arr2, int arr2Size, int* returnSize) {
    // Count frequencies using array (assuming values <= 1000)
    int count[1001] = {0};
    for (int i = 0; i < arr1Size; i++) {
        count[arr1[i]]++;
    }
    
    int* result = (int*)malloc(arr1Size * sizeof(int));
    int resultIndex = 0;
    
    // Add elements in arr2 order with their frequencies
    for (int i = 0; i < arr2Size; i++) {
        int num = arr2[i];
        for (int j = 0; j < count[num]; j++) {
            result[resultIndex++] = num;
        }
        count[num] = 0; // Mark as processed
    }
    
    // Add remaining elements in sorted order
    for (int num = 0; num <= 1000; num++) {
        for (int j = 0; j < count[num]; j++) {
            result[resultIndex++] = num;
        }
    }
    
    *returnSize = arr1Size;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m + k log k)

O(n) for counting frequencies, O(m) for processing arr2 order, O(k log k) for sorting remaining elements

⚡ Linearithmic

Space Complexity

O(n + m)

O(n) for frequency counting and O(m) for priority mapping, plus O(k) for remaining elements

⚡ Linearithmic Space

89.5K Views

Medium Frequency

~15 min Avg. Time

2.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

Counting Sort (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler