Reorder an array according to given indexes

Given two integer arrays of same size, “arr[]” and “index[]”, reorder elements in “arr[]” according to given index array. It is not allowed to given array arr’s length.

Example: 

Input:  arr[]   = [10, 11, 12];
        index[] = [1, 0, 2];
Output: arr[]   = [11, 10, 12]
        index[] = [0,  1,  2] 

Input:  arr[]   = [50, 40, 70, 60, 90]
        index[] = [3,  0,  4,  1,  2]
Output: arr[]   = [40, 60, 90, 50, 70]
        index[] = [0,  1,  2,  3,   4]

Expected time complexity O(n) and auxiliary space O(1)

We strongly recommend you to minimize your browser and try this yourself first.
A Simple Solution is to use an auxiliary array temp[] of same size as given arrays. Traverse the given array and put all elements at their correct place in temp[] using index[]. Finally copy temp[] to arr[] and set all values of index[i] as i. 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to sort an array according to given
// indexes
#include<iostream>
 
using namespace std;
 
// Function to reorder elements of arr[] according
// to index[]
void reorder(int arr[], int index[], int n)
{
    int temp[n];
 
    // arr[i] should be present at index[i] index
    for (int i=0; i<n; i++)
        temp[index[i]] = arr[i];
 
    // Copy temp[] to arr[]
    for (int i=0; i<n; i++)
    {
       arr[i]   = temp[i];
       index[i] = i;
    }
}
 
// Driver program
int main()
{
    int arr[] = {50, 40, 70, 60, 90};
    int index[] = {3,  0,  4,  1,  2};
    int n = sizeof(arr)/sizeof(arr[0]);
 
    reorder(arr, index, n);
 
    cout << "Reordered array is: \n";
    for (int i=0; i<n; i++)
        cout << arr[i] << " ";
 
    cout << "\nModified Index array is: \n";
    for (int i=0; i<n; i++)
        cout << index[i] << " ";
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

//Java to find positions of zeroes flipping which
// produces maximum number of consecutive 1's
 
import java.util.Arrays;
 
class Test
{
    static int arr[] = new int[]{50, 40, 70, 60, 90};
    static int index[] = new int[]{30412};
     
    // Method to reorder elements of arr[] according
    // to index[]
    static void reorder()
    {
        int temp[] = new int[arr.length];
      
        // arr[i] should be present at index[i] index
        for (int i=0; i<arr.length; i++)
            temp[index[i]] = arr[i];
      
        // Copy temp[] to arr[]
        for (int i=0; i<arr.length; i++)
        {
           arr[i]   = temp[i];
           index[i] = i;
        }
    }
     
    // Driver method to test the above function
    public static void main(String[] args)
    {
         
        reorder();
         
        System.out.println("Reordered array is: ");
        System.out.println(Arrays.toString(arr));
        System.out.println("Modified Index array is:");
        System.out.println(Arrays.toString(index));
         
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to sort
# an array according to given
# indexes
 
# Function to reorder
# elements of arr[] according
# to index[]
def reorder(arr,index, n):
 
    temp = [0] * n;
 
    # arr[i] should be
        # present at index[i] index
    for i in range(0,n):
        temp[index[i]] = arr[i]
 
    # Copy temp[] to arr[]
    for i in range(0,n):
        arr[i] = temp[i]
        index[i] = i
     
# Driver program
arr = [50, 40, 70, 60, 90]
index = [3, 0, 4, 1, 2]
n = len(arr)
 
reorder(arr, index, n)
 
print("Reordered array is:")
for i in range(0,n):
    print(arr[i],end = " ")
 
print("\nModified Index array is:")
for i in range(0,n):
    print(index[i],end = " ")
 
# This code is contributed by
# Smitha Dinesh Semwal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# to find positions of zeroes flipping which
// produces maximum number of consecutive 1's
using System;
  
public class Test{
     
    static int []arr = new int[]{50, 40, 70, 60, 90};
    static int []index = new int[]{3,  0,  4,  1,  2};
      
    // Method to reorder elements of arr[] according
    // to index[]
    static void reorder()
    {
        int []temp = new int[arr.Length];
       
        // arr[i] should be present at index[i] index
        for (int i=0; i<arr.Length; i++)
            temp[index[i]] = arr[i];
       
        // Copy temp[] to arr[]
        for (int i=0; i<arr.Length; i++)
        {
           arr[i]   = temp[i];
           index[i] = i;
        }
    }
      
    // Driver method to test the above function
    public static void Main()
    {
          
        reorder();
          
        Console.WriteLine("Reordered array is: ");
        Console.WriteLine(string.Join(",", arr));
        Console.WriteLine("Modified Index array is:");
        Console.WriteLine(string.Join(",", index));
          
    }
}
/*This code is contributed by 29AjayKumar*/

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to sort an array
// according to given indexes
 
// Function to reorder elements
// of arr[] according to index[]
function reorder($arr, $index, $n)
{
    // $temp[$n];
 
    // arr[i] should be present
    // at index[i] index
    for ($i = 0; $i < $n; $i++)
    {
        $temp[$index[$i]] = $arr[$i];
    }
     
     
    // Copy temp[] to arr[]
    for ($i = 0; $i < $n; $i++)
    {
        $arr[$i] = $temp[$i];
        $index[$i] = $i;
    }
     
    echo "Reordered array is: \n";
for ($i = 0; $i < $n; $i++)
{
    echo $arr[$i] . " ";
}
 
echo "\nModified Index array is: \n";
for ($i = 0; $i < $n; $i++)
{
    echo $index[$i] . " ";
}
}
 
// Driver Code
$arr = array(50, 40, 70, 60, 90);
$index = array(3, 0, 4, 1, 2);
$n = sizeof($arr);
 
reorder($arr, $index, $n);
 
// This code is contributed
// by Abby_akku
?>

chevron_right


Output:



Reordered array is: 
40 60 90 50 70 
Modified Index array is: 
0 1 2 3 4

Thanks to gccode for suggesting above solution.
We can solve it Without Auxiliary Array. Below is algorithm. 

1) Do following for every element arr[i]
   a) While index[i] is not equal to i
       (i)  Store array and index values of the target (or 
            correct) position where arr[i] should be placed.
            The correct position for arr[i] is index[i]
       (ii) Place arr[i] at its correct position. Also
            update index value of correct position.
       (iii) Copy old values of correct position (Stored in
            step (i)) to arr[i] and index[i] as the while 
            loop continues for i.

Below is implementation of above algorithm. 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// A O(n) time and O(1) extra space C++ program to
// sort an array according to given indexes
#include<iostream>
 
using namespace std;
 
// Function to reorder elements of arr[] according
// to index[]
void reorder(int arr[], int index[], int n)
{
    // Fix all elements one by one
    for (int i=0; i<n; i++)
    {
        // While index[i] and arr[i] are not fixed
        while (index[i] != i)
        {
            // Store values of the target (or correct)
            // position before placing arr[i] there
            int  oldTargetI  = index[index[i]];
            char oldTargetE  = arr[index[i]];
 
            // Place arr[i] at its target (or correct)
            // position. Also copy corrected index for
            // new position
            arr[index[i]] = arr[i];
            index[index[i]] = index[i];
 
            // Copy old target values to arr[i] and
            // index[i]
            index[i] = oldTargetI;
            arr[i]   = oldTargetE;
        }
    }
}
 
// Driver program
int main()
{
    int arr[] = {50, 40, 70, 60, 90};
    int index[] = {3,  0,  4,  1,  2};
    int n = sizeof(arr)/sizeof(arr[0]);
 
    reorder(arr, index, n);
 
    cout << "Reordered array is: \n";
    for (int i=0; i<n; i++)
        cout << arr[i] << " ";
 
    cout << "\nModified Index array is: \n";
    for (int i=0; i<n; i++)
        cout << index[i] << " ";
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

//A O(n) time and O(1) extra space Java program to
//sort an array according to given indexes
 
import java.util.Arrays;
 
class Test
{
    static int arr[] = new int[]{50, 40, 70, 60, 90};
    static int index[] = new int[]{30412};
     
    // Method to reorder elements of arr[] according
    // to index[]
    static void reorder()
    {
        // Fix all elements one by one
        for (int i=0; i<arr.length; i++)
        {
            // While index[i] and arr[i] are not fixed
            while (index[i] != i)
            {
                // Store values of the target (or correct)
                // position before placing arr[i] there
                int  oldTargetI  = index[index[i]];
                char oldTargetE  = (char)arr[index[i]];
      
                // Place arr[i] at its target (or correct)
                // position. Also copy corrected index for
                // new position
                arr[index[i]] = arr[i];
                index[index[i]] = index[i];
      
                // Copy old target values to arr[i] and
                // index[i]
                index[i] = oldTargetI;
                arr[i]   = oldTargetE;
            }
        }
    }
     
    // Driver method to test the above function
    public static void main(String[] args)
    {
         
        reorder();
         
        System.out.println("Reordered array is: ");
        System.out.println(Arrays.toString(arr));
        System.out.println("Modified Index array is:");
        System.out.println(Arrays.toString(index));
         
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# A O(n) time and O(1) extra space Python3 program to
# sort an array according to given indexes
 
# Function to reorder elements of arr[] according
# to index[]
def reorder(arr, index, n):
 
    # Fix all elements one by one
    for i in range(0,n):
 
           #  While index[i] and arr[i] are not fixed
           while (index[i] != i):
         
               # Store values of the target (or correct)
               # position before placing arr[i] there
               oldTargetI = index[index[i]]
               oldTargetE = arr[index[i]]
 
               # Place arr[i] at its target (or correct)
               # position. Also copy corrected index for
               # new position
               arr[index[i]] = arr[i]
               index[index[i]] = index[i]
 
               # Copy old target values to arr[i] and
               # index[i]
               index[i] = oldTargetI
               arr[i] = oldTargetE
 
 
# Driver program
arr = [50, 40, 70, 60, 90]
index= [3, 0, 4, 1, 2]
n = len(arr)
 
reorder(arr, index, n)
 
print("Reordered array is:")
for  i in range(0, n):
    print(arr[i],end=" ")
 
print("\nModified Index array is:")
for i in range(0, n):
    print(index[i] ,end=" ")
 
# This code is contributed by
# Smitha Dinesh Semwal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

//A O(n) time and O(1) extra space C# program to
//sort an array according to given indexes
using System;
 
public class Test
{
    static int []arr = new int[]{50, 40, 70, 60, 90};
    static int []index = new int[]{3,  0,  4,  1,  2};
      
    // Method to reorder elements of arr[] according
    // to index[]
    static void reorder()
    {
        // Fix all elements one by one
        for (int i=0; i<arr.Length; i++)
        {
            // While index[i] and arr[i] are not fixed
            while (index[i] != i)
            {
                // Store values of the target (or correct)
                // position before placing arr[i] there
                int  oldTargetI  = index[index[i]];
                char oldTargetE  = (char)arr[index[i]];
       
                // Place arr[i] at its target (or correct)
                // position. Also copy corrected index for
                // new position
                arr[index[i]] = arr[i];
                index[index[i]] = index[i];
       
                // Copy old target values to arr[i] and
                // index[i]
                index[i] = oldTargetI;
                arr[i]   = oldTargetE;
            }
        }
    }
      
    // Driver method to test the above function
    public static void Main()
    {
          
        reorder();
          
        Console.WriteLine("Reordered array is: ");
        Console.WriteLine(String.Join(" ",arr));
        Console.WriteLine("Modified Index array is:");
        Console.WriteLine(String.Join(" ",index));
          
    }
}
 
// This code is contributed by PrinciRaj1992

chevron_right


Output:

Reordered array is: 
40 60 90 50 70 
Modified Index array is: 
0 1 2 3 4

Thanks to shyamala_lokre for suggesting above solution.

Another Method without using an auxiliary array is to sort the arrays. 
Sort the index array and customize the sort to swap the arr[] data whenever you swap the index[] data.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

//C++ code to reorder an array according to given indices
#include <bits/stdc++.h>
 
using namespace std;
 
int heapSize;
 
void swap ( int &a, int &b ) {
    int temp = a;
    a = b;
    b = temp;
}
 
void heapify( int arr[], int index[], int i )
{
    int largest = i;
    // left child in 0 based indexing
    int left = 2 * i + 1;
    // right child in 1 based indexing
    int right = 2 * i + 2;
    // find largest index from root, left and right child
    if( left < heapSize && index[left] > index[largest] )
    {
        largest = left;
    }
    if( right < heapSize && index[right] > index[largest] )
    {
        largest = right;
    }
     
    if ( largest != i ) {
        //swap arr whenever index is swapped
        swap(arr[largest], arr[i]);
        swap(index[largest], index[i]);
        heapify(arr, index, largest);
    }
}
 
void heapSort( int arr[], int index[], int n ) {
// Build heap
    for ( int i = ( n - 1 ) / 2 ; i >= 0 ; i-- ) {
        heapify(arr, index, i);
    }
    // Swap the largest element of index(first element)
    // with the last element
    for ( int i = n - 1 ; i > 0 ; i-- ) {
        swap(index[0], index[i]);
        //swap arr whenever index is swapped
        swap(arr[0], arr[i]);
        heapSize--;
        heapify(arr, index, 0);
    }
}
 
// Driver Code
int main() {
    int arr[] = {50, 40, 70, 60, 90};
    int index[] = {3,  0,  4,  1,  2};
    int n = sizeof(arr)/sizeof(arr[0]);
    heapSize = n;
    heapSort(arr, index, n);
 
    cout << "Reordered array is: \n";
    for ( int i = 0 ; i < n ; i++ )
        cout << arr[i] << " ";
         
        cout << "\nModified Index array is: \n";
    for (int i=0; i<n; i++)
        cout << index[i] << " ";
 
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java code to reorder an array
// according to given indices
class GFG{
     
static int heapSize;
 
public static void heapify(int arr[],
                           int index[], int i)
{
    int largest = i;
     
    // left child in 0 based indexing
    int left = 2 * i + 1;
     
    // right child in 1 based indexing
    int right = 2 * i + 2;
     
    // Find largest index from root,
    // left and right child
    if (left < heapSize &&
        index[left] > index[largest] )
    {
        largest = left;
    }
    if (right < heapSize &&
        index[right] > index[largest] )
    {
        largest = right;
    }
      
    if (largest != i)
    {
         
        // swap arr whenever index is swapped
        int temp = arr[largest];
        arr[largest] = arr[i];
        arr[i] = temp;
         
        temp = index[largest];
        index[largest] = index[i];
        index[i] = temp;
         
        heapify(arr, index, largest);
    }
}
  
public static void heapSort(int arr[],
                            int index[], int n)
{
     
    // Build heap
    for(int i = (n - 1) / 2 ; i >= 0 ; i--)
    {
        heapify(arr, index, i);
    }
     
    // Swap the largest element of
    // index(first element)
    // with the last element
    for(int i = n - 1 ; i > 0 ; i--)
    {
        int temp = index[0];
        index[0] = index[i];
        index[i] = temp;
         
        // swap arr whenever index is swapped
        temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
         
        heapSize--;
        heapify(arr, index, 0);
    }
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 50, 40, 70, 60, 90 };
    int index[] = { 3, 0, 4, 1, 2 };
    int n = arr.length;
     
    heapSize = n;
    heapSort(arr, index, n);
     
    System.out.println("Reordered array is: ");
    for(int i = 0 ; i < n ; i++)
        System.out.print(arr[i] + " ");
         
    System.out.println();  
     
    System.out.println("Modified Index array is: ");
    for(int i = 0; i < n; i++)
        System.out.print(index[i] + " ");
}
}
 
// This code is contributed by divyeshrabadiya07

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 code to reorder an array
# according to given indices
def heapify(arr, index, i):
     
    largest = i
     
    # left child in 0 based indexing
    left = 2 * i + 1
     
    # right child in 1 based indexing
    right = 2 * i + 2
     
    global heapSize
 
    # Find largest index from root,
    # left and right child
    if (left < heapSize and
        index[left] > index[largest]):
        largest = left
 
    if (right < heapSize and
        index[right] > index[largest]):
        largest = right
 
    if (largest != i):
         
        # Swap arr whenever index is swapped
        arr[largest], arr[i] = arr[i], arr[largest]
        index[largest], index[i] = index[i], index[largest]
 
        heapify(arr, index, largest)
 
def heapSort(arr, index, n):
     
    # Build heap
    global heapSize
     
    for i in range(int((n - 1) / 2), -1, -1):
        heapify(arr, index, i)
         
    # Swap the largest element of
    # index(first element) with
    # the last element
    for i in range(n - 1, 0, -1):
        index[0], index[i] = index[i], index[0]
         
        # Swap arr whenever index is swapped
        arr[0], arr[i] = arr[i], arr[0]
 
        heapSize -= 1
        heapify(arr, index, 0)
 
# Driver Code
arr = [ 50, 40, 70, 60, 90 ]
index = [ 3, 0, 4, 1, 2 ]
 
n = len(arr)
global heapSize
heapSize = n
heapSort(arr, index, n)
 
print("Reordered array is: ")
print(*arr, sep = ' ')
print("Modified Index array is: ")
print(*index, sep = ' ')
 
# This code is contributed by avanitrachhadiya2155

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# code to reorder an array
// according to given indices
using System;
using System.Collections.Generic;
 
class GFG{
     
static int heapSize;
 
public static void heapify(int[] arr,
                           int[] index,
                           int i)
{
    int largest = i;
     
    // left child in 0 based indexing
    int left = 2 * i + 1;
      
    // right child in 1 based indexing
    int right = 2 * i + 2;
      
    // Find largest index from root,
    // left and right child
    if (left < heapSize &&
        index[left] > index[largest] )
    {
        largest = left;
    }
    if (right < heapSize &&
        index[right] > index[largest] )
    {
        largest = right;
    }
       
    if (largest != i)
    {
         
        // Swap arr whenever index is swapped
        int temp = arr[largest];
        arr[largest] = arr[i];
        arr[i] = temp;
          
        temp = index[largest];
        index[largest] = index[i];
        index[i] = temp;
          
        heapify(arr, index, largest);
    }
}
   
public static void heapSort(int[] arr,
                            int[] index,
                            int n)
{
     
    // Build heap
    for(int i = (n - 1) / 2 ; i >= 0 ; i--)
    {
        heapify(arr, index, i);
    }
      
    // Swap the largest element of
    // index(first element)
    // with the last element
    for(int i = n - 1 ; i > 0 ; i--)
    {
        int temp = index[0];
        index[0] = index[i];
        index[i] = temp;
          
        // Swap arr whenever index
        // is swapped
        temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
          
        heapSize--;
        heapify(arr, index, 0);
    }
}
 
// Driver Code
static void Main()
{
    int[] arr = { 50, 40, 70, 60, 90 };
    int[] index = { 3, 0, 4, 1, 2 };
    int n = arr.Length;
      
    heapSize = n;
    heapSort(arr, index, n);
      
    Console.WriteLine("Reordered array is: ");
    for(int i = 0 ; i < n ; i++)
        Console.Write(arr[i] + " ");
          
    Console.WriteLine();
      
    Console.WriteLine("Modified Index array is: ");
    for(int i = 0; i < n; i++)
        Console.Write(index[i] + " ");
}
}
 
// This code is contributed by divyesh072019

chevron_right


Output:

Reordered array is: 
40 60 90 50 70 
Modified Index array is: 
0 1 2 3 4

Time Complexity: O(nlogn)
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :


19


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.