Open In App

Sort an array according to the order defined by another array

Last Updated : 23 Jul, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

Given two arrays arr1[] and arr2[], find a sorted version of arr1[] where elements follow the order of arr2[]. Elements not in arr2[] should appear at the end in ascending order.

Example: 

Input: arr1[] = [2, 1, 2, 5, 7, 1, 9, 3, 6, 8, 8]
           arr2[] = [2, 1, 8, 3]
Output: [2, 2, 1, 1, 8, 8, 3, 5, 6, 7, 9]
Explanation: Elements in arr1[] that are also present in arr2[] appear first, following the exact order given in arr2[]. The remaining elements, which are not in arr2[], are sorted in ascending order and placed at the end of the array.

Input: arr1[] = [4, 5, 1, 1, 3, 2]
           arr2[] = [3, 1]
Output: [3, 1, 1, 2, 4, 5]
Explanation: Elements follow the order of arr2[], others are sorted and placed at the end.

Table of Content

[Approach 1] Using Hashing - O(m log m + n) Time and O(m) Space

The main idea is to use a hash map to count frequencies of elements in arr1, so we can efficiently place elements in the desired order. Then, iterate through arr2 to append matching elements in order, followed by the sorted remaining elements from arr1. This ensures correct relative order from arr2, and sorted placement of extras.

Step-By-Step Approach:

  • Count frequency of each element in arr1 using a hash map.
  • Add elements from arr2 to the result based on their frequency.
  • Remove those elements from the map after processing.
  • Sort and add the remaining elements to the result using their frequency.
C++ 
#include <bits/stdc++.h>
using namespace std;

void relativeSort(vector<int>& arr1, vector<int>& arr2){
    
    int m = arr1.size(), n = arr2.size();
    unordered_map<int, int> freq;

    // Count frequency of each element in arr1
    for (int i = 0; i < m; i++) {
        freq[arr1[i]]++;
    }

    int index = 0;

    // Place elements of arr2 in arr1 based on frequency
    for (int i = 0; i < n; i++) {
        while (freq[arr2[i]]) {
            arr1[index++] = arr2[i];
            freq[arr2[i]]--;
        }
        freq.erase(arr2[i]);
    }

    // Collect remaining elements and sort them
    vector<int> remaining;
    for (auto& pair : freq) {
        while (pair.second--) {
            remaining.push_back(pair.first);
        }
    }
    sort(remaining.begin(), remaining.end());

    // Append remaining elements to arr1
    for (int i : remaining) {
        arr1[index++] = i;
    }
}

// Driver code
int main(){
    
    vector<int> arr1 = { 2, 1, 2, 5, 7, 1, 9, 3, 6, 8, 8 };
    vector<int> arr2 = { 2, 1, 8, 3 };

    relativeSort(arr1, arr2);
    
    for (int i = 0; i < arr1.size(); i++) {
        cout << arr1[i] << " ";
    }
    
    cout << endl;
    return 0;
}
Java 
import java.util.*;

class GfG {

    static void relativeSort(int[] arr1, int[] arr2) {
        
        int m = arr1.length, n = arr2.length;
        Map<Integer, Integer> freq = new HashMap<>();

        // Count frequency of each element in arr1
        for (int num : arr1) {
            freq.put(num, freq.getOrDefault(num, 0) + 1);
        }

        int index = 0;

        // Place elements of arr2 in arr1 according to their frequency
        for (int i = 0; i < n; i++) {
            int val = arr2[i];
            while (freq.getOrDefault(val, 0) > 0) {
                arr1[index++] = val;
                freq.put(val, freq.get(val) - 1);
            }
            freq.remove(val);
        }

        // Store remaining elements
        List<Integer> remaining = new ArrayList<>();
        for (Map.Entry<Integer, Integer> entry : freq.entrySet()) {
            int val = entry.getKey();
            int count = entry.getValue();
            while (count-- > 0) {
                remaining.add(val);
            }
        }

        // Sort and append remaining elements
        Collections.sort(remaining);
        for (int val : remaining) {
            arr1[index++] = val;
        }
    }

    // Driver code
    public static void main(String[] args) {
        int[] arr1 = {2, 1, 2, 5, 7, 1, 9, 3, 6, 8, 8};
        int[] arr2 = {2, 1, 8, 3};

        relativeSort(arr1, arr2);

        // Print output
        for (int num : arr1) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}
Python 
from collections import Counter

# Sorts arr1 based on the order defined in arr2
def relativeSort(arr1, arr2):
    
    # Count frequency of each element in arr1
    freq = Counter(arr1)  
    index = 0

    # Place elements from arr2 first, in their given order
    for num in arr2:
        while freq[num] > 0:
            arr1[index] = num
            index += 1
            freq[num] -= 1

    # Append the remaining elements (not in arr2), sorted
    for num in sorted(freq.elements()):
        arr1[index] = num
        index += 1

if __name__ == "__main__":
    arr1 = [2, 1, 2, 5, 7, 1, 9, 3, 6, 8, 8]
    arr2 = [2, 1, 8, 3]
    
    relativeSort(arr1, arr2)
    print(*arr1)
C# 
using System;
using System.Collections.Generic;

class GfG{
    
    static void relativeSort(ref int[] arr1, int[] arr2){
        
        // Count frequencies of elements in arr1
        Dictionary<int, int> freq = new Dictionary<int, int>();
        foreach (int num in arr1){
            
            if (freq.ContainsKey(num))
                freq[num]++;
            else
                freq[num] = 1;
        }

        int index = 0;

        // Place elements from arr2 first, in order
        foreach (int num in arr2){
            
            while (freq.ContainsKey(num) && freq[num] > 0){
                
                arr1[index++] = num;
                freq[num]--;
            }
            
            // Remove to avoid duplication
            freq.Remove(num); 
        }

        // Gather remaining elements and sort them
        List<int> remaining = new List<int>();
        foreach (var pair in freq){
            
            for (int i = 0; i < pair.Value; i++)
                remaining.Add(pair.Key);
        }
        remaining.Sort();

        // Append remaining sorted elements to arr1
        foreach (int num in remaining){
            
            arr1[index++] = num;
        }
    }

    public static void Main(string[] args){
        
        int[] arr1 = { 2, 1, 2, 5, 7, 1, 9, 3, 6, 8, 8 };
        int[] arr2 = { 2, 1, 8, 3 };

        relativeSort(ref arr1, arr2);

        // Print arr1
        foreach (int num in arr1){
            Console.Write(num + " ");
        }
        Console.WriteLine();
    }
}
JavaScript 
function relativeSort(arr1, arr2) {
    
    // Count frequency of each element in arr1
    const freq = {};
    for (let num of arr1) {
        freq[num] = (freq[num] || 0) + 1;
    }

    let index = 0;

    // Place elements from arr2 into arr1 based on their frequency
    for (let num of arr2) {
        while (freq[num] > 0) {
            arr1[index++] = num;
            freq[num]--;
        }
        // Remove after processing
        delete freq[num]; 
    }

    // Collect and sort remaining elements not in arr2
    const remaining = [];
    for (let key in freq) {
        for (let i = 0; i < freq[key]; i++) {
            remaining.push(Number(key));
        }
    }
    remaining.sort((a, b) => a - b);

    // Add remaining sorted elements to arr1
    for (let num of remaining) {
        arr1[index++] = num;
    }
}

// Driver Code
const arr1 = [2, 1, 2, 5, 7, 1, 9, 3, 6, 8, 8];
const arr2 = [2, 1, 8, 3];
relativeSort(arr1, arr2);

// Print result
arr1.forEach(num => process.stdout.write(num + " "));
console.log();

Output
2 2 1 1 8 8 3 5 6 7 9

Time complexity: O(m log m + n), where m is the size of arr1 and n is the size of arr2.
Auxiliary Space: O(m)

[Approach 2] Using a Custom Comparator - O(m log(m) + n) Time and O(n) Space

The idea behind this approach is to use a custom sorting method to order the elements of arr1 based on the order defined by arr2. Elements found in arr2 are given higher priority based on their position in arr2, and those not in arr2 are placed at the end in ascending order. A map is used to quickly look up the priority of elements from arr2.

Step-By-Step Approach:

  • Create a map from arr2 where each element is mapped to its index (priority).
  • Use sort() on arr1 with a custom comparator function.
  • In the comparator:
    • If both elements are in arr2, compare by their index in the map.
    • If only one is in arr2, that one comes first.
    • If neither is in arr2, compare normally (numerical sort).
  • Return the sorted arr1 as the result.
C++ 
#include <bits/stdc++.h>
using namespace std;

void relativeSort(vector<int>& arr1, vector<int>& arr2) {
    
    // Map to store the position of each element in arr2
    unordered_map<int, int> index;
    
    for (int i = 0; i < arr2.size(); i++) {
     
        if (index[arr2[i]] == 0) {
            // Use i+1 to avoid default 0
            index[arr2[i]] = i + 1; 
        }
    }

    // Custom comparator for sorting
    auto comp = [&](int a, int b) {
        
        // If both not in arr2, sort normally
        if (index[a] == 0 && index[b] == 0)
            return a < b;

        // If only a is missing, b comes first
        if (index[a] == 0)
            return false;

        // If only b is missing, a comes first
        if (index[b] == 0)
            return true;

        // If both present, sort by their position in arr2
        return index[a] < index[b];
    };

    sort(arr1.begin(), arr1.end(), comp);
}

int main() {

    vector<int> arr1{2, 1, 2, 5, 7, 1, 9, 3, 6, 8, 8};
    vector<int> arr2{2, 1, 8, 3};

    relativeSort(arr1, arr2);

    for (int num : arr1) {
        cout << num << " ";
    }

    return 0;
}
Java 
import java.util.*;

class GfG {

    static void relativeSort(int[] arr1, int[] arr2) {
        
        HashMap<Integer, Integer> index = new HashMap<>();

        // Map each element of arr2 to its position
        for (int i = 0; i < arr2.length; i++) {
            if (!index.containsKey(arr2[i])) {
                
                // use i+1 to avoid default 0
                index.put(arr2[i], i + 1); 
            }
        }

        // Convert arr1 to list and sort using custom comparator
        ArrayList<Integer> list = new ArrayList<>();
        for (int num : arr1) list.add(num);

        list.sort((a, b) -> {
            int idxA = index.getOrDefault(a, 0);
            int idxB = index.getOrDefault(b, 0);

            if (idxA == 0 && idxB == 0) return a - b;
            if (idxA == 0) return 1;
            if (idxB == 0) return -1;
            return idxA - idxB;
        });

        // Copy back to arr1
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = list.get(i);
        }

    }

    public static void main(String[] args) {
        int[] arr1 = {2, 1, 2, 5, 7, 1, 9, 3, 6, 8, 8};
        int[] arr2 = {2, 1, 8, 3};

        relativeSort(arr1, arr2);
        
        // Print the sorted array in C++ style
        for (int num : arr1) {
            System.out.print(num + " ");
        }
    }
}
Python 
import functools

# Sort arr1 according to the order defined in arr2
def relativeSort(arr1, arr2):
    
    # Map to store index of each element in arr2
    index = {}
    
    for i in range(len(arr2)):
        if arr2[i] not in index:
        
            # Use i+1 to avoid default 0
            index[arr2[i]] = i + 1  

    # Custom comparator
    def cmp(a, b):
        if a not in index and b not in index:
            # Normal sort
            return a - b  
    
        if a not in index:
            # b comes first
            return 1     
            
        if b not in index:
             # a comes first
            return -1    
        return index[a] - index[b]  

    arr1.sort(key=functools.cmp_to_key(cmp))


if __name__ == "__main__":
    arr1 = [2, 1, 2, 5, 7, 1, 9, 3, 6, 8, 8]
    arr2 = [2, 1, 8, 3]
    
    relativeSort(arr1, arr2)
    
    # Print sorted result
    print(*arr1)
C# 
using System;
using System.Collections.Generic;

class GfG{
    
    // Sorts arr1 based on the order in arr2
    static void relativeSort(ref int[] arr1, int[] arr2){
        
        Dictionary<int, int> index = new Dictionary<int, int>();

        // Map each element in arr2 to its position
        for (int i = 0; i < arr2.Length; i++){
            
            if (!index.ContainsKey(arr2[i])){
                // Avoid conflict with default 0
                index[arr2[i]] = i + 1; 
            }
        }

        // Sort arr1 using custom comparison logic
        Array.Sort(arr1, (a, b) =>{
            
            int idxA = index.ContainsKey(a) ? index[a] : 0;
            int idxB = index.ContainsKey(b) ? index[b] : 0;

            if (idxA == 0 && idxB == 0) return a.CompareTo(b);
            if (idxA == 0) return 1;
            if (idxB == 0) return -1;
            return idxA.CompareTo(idxB);
        });
    }

    static void Main(string[] args){
        
        int[] arr1 = {2, 1, 2, 5, 7, 1, 9, 3, 6, 8, 8};
        int[] arr2 = {2, 1, 8, 3};

        relativeSort(ref arr1, arr2);

        // Print sorted arr1 
        foreach (int num in arr1){
            
            Console.Write(num + " ");
        }
        Console.WriteLine();
    }
}
JavaScript 
function relativeSort(arr1, arr2) {

    // Create a map to store the position of each element in arr2
     const priority = new Map();
    arr2.forEach((val, idx) => {
        priority.set(val, idx);
    });

    // Custom comparator inside sort()
    arr1.sort((a, b) => {
        const aIn = priority.has(a);
        const bIn = priority.has(b);

        if (aIn && bIn) {
            // Sort by position in arr2
            return priority.get(a) - priority.get(b); 
        } else if (aIn) {
            // a comes before b
            return -1; 
            
        } else if (bIn) {
            // b comes before a
            return 1; 
        } else {
            // both not in arr2, sort numerically
            return a - b; 
        }
    });

    return arr1;  
}

// Driver Code
const arr1 = [2, 1, 2, 5, 7, 1, 9, 3, 6, 8, 8];
const arr2 = [2, 1, 8, 3];

relativeSort(arr1, arr2);

// Print result
arr1.forEach(num => process.stdout.write(num + " "));
console.log();

Output
2 2 1 1 8 8 3 5 6 7 9

Time complexity: O(m log(m) + n, m*log(m) for sorting arr1[] of size m and n for iterating over arr2[] of size n.
Auxiliary Space: O(n), Storing first occurrence of every element of arr2[] of size n.



Sort an array according to the other | DSA Problem
Next Article
Analysis of Algorithms

K
kartik
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox