Relative Sort Array

Relative Sort Array - Problem

Given two arrays arr1 and arr2, the elements of arr2 are distinct, and all elements in arr2 are also in arr1.

Sort the elements of arr1 such that the relative ordering of items in arr1 are the same as in arr2. Elements that do not appear in arr2 should be placed at the end of arr1 in ascending order.

Input & Output

Example 1 — Basic Relative Sorting

$ 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: Follow arr2 order: 2 appears 3 times (2,2,2), 1 appears 1 time (1), 4 appears 1 time (4), 3 appears 2 times (3,3), 9 appears 1 time (9), 6 appears 1 time (6). Remaining elements [7,19] are sorted in ascending order.

Example 2 — No Remaining Elements

$ Input: arr1 = [2,3,1,3,2,4], arr2 = [2,1,4,3]

› Output: [2,2,1,4,3,3]

💡 Note: All elements in arr1 appear in arr2. Follow arr2 order: 2 appears twice, 1 once, 4 once, 3 twice. No remaining elements to sort.

Example 3 — Edge Case with Singles

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

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

💡 Note: Follow arr2 order for first 4 elements. Remaining elements [17,44] are sorted: 17 < 44, so result ends with [17,44].

Constraints

1 ≤ arr1.length, arr2.length ≤ 1000
0 ≤ arr1[i], arr2[i] ≤ 1000
All the elements of arr2 are unique
Each arr2[i] is in arr1

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 32 f Facebook 28 M Microsoft 25

The key insight is to use frequency counting to track element occurrences, then build the result by following arr2's order and sorting remaining elements. The optimal approach uses a hash map for O(1) frequency lookups. Time: O(n + m + k log k), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Multiple Scans	O(n × m + k log k)	O(k)	For each element in arr2, scan arr1 multiple times to find and collect all occurrences
Frequency Count with Hash Map	O(n + m + k log k)	O(n)	Count frequencies of all elements, then build result following arr2 order

Brute Force - Multiple Scans — Algorithm Steps

For each element in arr2, scan arr1 to find all occurrences
Add found elements to result in order
Scan arr1 again to find elements not in arr2
Sort remaining elements and append to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan for 2

Find all occurrences of 2 in arr1

Scan for 1

Find all occurrences of 1 in arr1

Sort Remaining

Sort elements not in arr2

Code -

solution.c — C

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

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

int* solution(int* arr1, int arr1Size, int* arr2, int arr2Size, int* returnSize) {
    int* result = (int*)malloc(arr1Size * sizeof(int));
    bool* used = (bool*)calloc(arr1Size, sizeof(bool));
    int resultIndex = 0;
    
    // For each element in arr2, find all occurrences in arr1
    for (int i = 0; i < arr2Size; i++) {
        for (int j = 0; j < arr1Size; j++) {
            if (arr1[j] == arr2[i] && !used[j]) {
                result[resultIndex++] = arr1[j];
                used[j] = true;
            }
        }
    }
    
    // Collect remaining elements not in arr2
    int* remaining = (int*)malloc(arr1Size * sizeof(int));
    int remainingSize = 0;
    for (int i = 0; i < arr1Size; i++) {
        if (!used[i]) {
            remaining[remainingSize++] = arr1[i];
        }
    }
    
    // Sort remaining elements and add to result
    qsort(remaining, remainingSize, sizeof(int), compare);
    for (int i = 0; i < remainingSize; i++) {
        result[resultIndex++] = remaining[i];
    }
    
    *returnSize = resultIndex;
    free(used);
    free(remaining);
    return result;
}

int main() {
    // Simple parsing for demo - in practice would need robust JSON parsing
    int arr1[] = {2,3,1,3,2,4,6,7,9,2,19};
    int arr2[] = {2,1,4,3,9,6};
    int returnSize;
    
    int* result = solution(arr1, 11, arr2, 6, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m + k log k)

For each of m elements in arr2, scan n elements in arr1, plus sorting k remaining elements

⚡ Linearithmic

Space Complexity

O(k)

Extra space for storing k remaining elements to sort

✓ Linear Space

38.4K 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 - Multiple Scans — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler