Skip to content
Related Articles

Related Articles

Reorder an array according to given indexes

View Discussion
Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 21 Aug, 2022
View Discussion
Improve Article
Save Article

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++




// 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;
}


Java




//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));
         
    }
}


Python3




# 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


C#




// 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*/


PHP




<?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
?>


Javascript




<script>
      // JavaScript program to sort an array according to given
      // indexes
 
      // Function to reorder elements of arr[] according
      // to index[]
      function reorder(arr, index, n) {
        var temp = [...Array(n)];
 
        // arr[i] should be present at index[i] index
        for (var i = 0; i < n; i++) temp[index[i]] = arr[i];
 
        // Copy temp[] to arr[]
        for (var i = 0; i < n; i++) {
          arr[i] = temp[i];
          index[i] = i;
        }
      }
 
      // Driver program
 
      var arr = [50, 40, 70, 60, 90];
      var index = [3, 0, 4, 1, 2];
      var n = arr.length;
 
      reorder(arr, index, n);
 
      document.write("Reordered array is: ");
      document.write("<br>");
      for (var i = 0; i < n; i++) document.write(arr[i] + " ");
      document.write("<br>");
      document.write("Modified Index array is: ");
      document.write("<br>");
      for (var i = 0; i < n; i++) document.write(index[i] + " ");
       
      // This code is contributed by rdtank.
    </script>


Output:

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

Thanks to gccode for suggesting the above solution.
Time Complexity: O(n) 
Auxiliary Space: O(n)

We can solve it Without Auxiliary Array. Below is the 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 the implementation of the above algorithm. 

C++




// 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;
}


Java




//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));
         
    }
}


Python3




# 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


C#




//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


Javascript




<script>
// A O(n) time and O(1) extra space JavaScript program to
// sort an array according to given indexes
 
// Function to reorder elements of arr[] according
// to index[]
function reorder(arr, index, n)
{
    // Fix all elements one by one
    for (let 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
            let oldTargetI = index[index[i]];
            let 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
    let arr = [50, 40, 70, 60, 90];
    let index = [3, 0, 4, 1, 2];
    let n = arr.length;
 
    reorder(arr, index, n);
 
    document.write("Reordered array is: <br>");
    for (let i=0; i<n; i++)
        document.write(arr[i] + " ");
 
    document.write("<br>Modified Index array is: <br>");
    for (let i=0; i<n; i++)
        document.write(index[i] + " ");
 
 
 
 
// This code is contributed by Surbhi Tyagi.
</script>


Output:

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

Thanks to shyamala_lokre for suggesting the above solution.

Time Complexity: O(n2
Auxiliary Space: O(1)

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++




//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;
}


Java




// 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


Python3




# 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


C#




// 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


Javascript




<script>
// Javascript code to reorder an array
// according to given indices
 
let heapSize;
 
function heapify(arr,index,i)
{
    let largest = i;
      
    // left child in 0 based indexing
    let left = 2 * i + 1;
      
    // right child in 1 based indexing
    let 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
        let temp = arr[largest];
        arr[largest] = arr[i];
        arr[i] = temp;
          
        temp = index[largest];
        index[largest] = index[i];
        index[i] = temp;
          
        heapify(arr, index, largest);
    }
}
 
function heapSort(arr,index,n)
{
    // Build heap
    for(let i = (n - 1) / 2 ; i >= 0 ; i--)
    {
        heapify(arr, index, i);
    }
      
    // Swap the largest element of
    // index(first element)
    // with the last element
    for(let i = n - 1 ; i > 0 ; i--)
    {
        let 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
let arr=[50, 40, 70, 60, 90 ];
 
let index=[3, 0, 4, 1, 2];
let n = arr.length;
 
heapSize = n;
heapSort(arr, index, n);
 
document.write("Reordered array is: <br>");
for(let i = 0 ; i < n ; i++)
    document.write(arr[i] + " ");
 
document.write("<br>"); 
 
document.write("Modified Index array is: <br>");
for(let i = 0; i < n; i++)
    document.write(index[i] + " ");
 
 
// This code is contributed by ab2127
</script>


Output:

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

Time Complexity: O(n log n)
Auxiliary Space: O(logn)

Another method to solve the problem is with space Complexity of O(1) is :-

Swap the elements present in the arr until the index_arr[i] is not equal to the i.

Let’s dry run the below code for the given input :- 

1st iteration :- (i=0)

arr = [ 50, 40, 70, 60, 90 ]

index_arr = [3, 0, 4, 1, 2 ]

since the index_arr[i] is not equal to i

swap the content present in the arr[i] with arr[index[i] and similarly swap for the index_arr also. After swapping we will have the following arr and index_arr values:- 

arr = [ 60, 40, 70, 50, 90 ]

index_arr = [1, 0, 4, 3, 2 ]

Since index_arr[0] is not equal to i.

we again swap the content present at i with index_arr[i] for both the arrays (arr , index_arr).

arr = [ 40, 60, 70, 50, 90 ]

index_arr = [0, 1, 4, 3, 2 ]

2nd Iteration:- (i=1)

Since the value of index_arr[i] == i ; condition under the while loop does not get executed as the condition under the braces get false and hence move to the next iteration:- 

3rd Iteration :- (i=2)

Since the value of index_arr[i] is not equal to i. Swap the content.

After Swapping we will get:- 

arr = [ 40, 60, 90, 50, 70 ]

index_arr = [0, 1, 2, 3, 4].

Now for the next iteration (4th and 5th iteration) since the Value of index_arr[i] is equal to i . we just skip that loop ( because the condition under the while loop gets false and hence the while loop does not get executed.) and move to the next iteration.

C++




// 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_arr[], 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_arr[i] != i) {
            swap(arr[i], arr[index_arr[i]]);
            swap(index_arr[i], index_arr[index_arr[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;
}
 
// This code is contributed by Aditya Kumar (adityakumar129)


Java




// A O(n) time and O(1) extra space Java program to
// sort an array according to given indexes
 
class ReorderArray {
    public static void swap(int arr[], int a, int b)
    {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
    // Function to reorder elements of arr[] according
    // to index[]
    public static void reorder(int arr[], int index_arr[],
                               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_arr[i] != i) {
                swap(arr, i, index_arr[i]);
                swap(index_arr, i, index_arr[i]);
            }
        }
    }
    // Driver program
    public static void main(String[] args)
    {
        int arr[] = { 50, 40, 70, 60, 90 };
        int index[] = { 3, 0, 4, 1, 2 };
        int n = arr.length;
        reorder(arr, index, n);
        System.out.print("Reordered array is: \n");
        for (int i = 0; i < n; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.print("\nModified Index array is: \n");
        for (int i = 0; i < n; i++) {
            System.out.print(index[i] + " ");
        }
    }
}
 
// This code is contributed by Tapesh(tapeshdua420)


Python3




# A O(n) time and O(1) extra space C++ program to
# sort an array according to given indexes
def swap(arr, i, j):
    temp = arr[i]
    arr[i] = arr[j]
    arr[j] = temp
 
# Function to reorder elements of arr[] according
# to index[]
def reorder(arr, index_arr, n):
   
  # Fix all elements one by one
    for i in range(n):
       
      # While index[i] and arr[i] are not fixed
        while index_arr[i] != i:
            swap(arr, i, index_arr[i])
            swap(index_arr, i, index_arr[i])
 
# Driver program
if __name__ == "__main__":
    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(n):
        print(arr[i], end=" ")
    print("\nModified Index array is: ")
    for i in range(n):
        print(index[i], end=" ")
 
# This code is contributed by Tapesh(tapeshdua420)


C#




// 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 void SwapNum(ref int x, ref int y)
  {
 
    int tempswap = x;
    x = y;
    y = tempswap;
  }
 
  // Function to reorder elements of arr[] according
  // to index[]
  static void reorder(int [] arr, int [] index, int n)
  {
 
    // 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)
      {
        SwapNum(ref arr[i], ref arr[index[i]]);
        SwapNum(ref index[i], ref index[index[i]]);
      }
    }
  }
 
  // Driver Code
  static void Main()
  {
    int[] arr = { 50, 40, 70, 60, 90 };
    int[] index = { 3, 0, 4, 1, 2 };
    int n = arr.Length;
 
    reorder(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 Aditya_Kumar


Javascript




<script>
// Javascript code to reorder an array
// according to given indices
 
// Function to reorder elements of arr[] according
// to index[]
 
function reorder(arr,index_arr,n)
{
 
    // Fix all elements one by one
    for(let i = 0 ; i < n ; i++)
    {
     
        // While index[i] and arr[i] are not fixed
        while(index_arr[i]!=i)
        {
            let temp = arr[i];
            arr[i] = arr[index_arr[i]];
            arr[index_arr[i]] = temp;
             
            let tmp = index_arr[i];
            index_arr[i] = index_arr[index_arr[i]];
            index_arr[index_arr[i]] = tmp;
        }
    }
}
 
// Driver code
let arr=[50, 40, 70, 60, 90 ];
 
let index=[3, 0, 4, 1, 2];
let n = arr.length;
 
reorder(arr, index, n);
 
document.write("Reordered array is: <br>");
for(let i = 0 ; i < n ; i++)
    document.write(arr[i] + " ");
 
document.write("<br>");
 
document.write("Modified Index array is: <br>");
for(let i = 0; i < n; i++)
    document.write(index[i] + " ");
 
// This code is contributed by Aarti_Rathi
</script>


Output

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

Time Complexity: O(n2
Auxiliary Space: O(1), since no extra space has been taken.

Please suggest if someone has a better solution which is more efficient in terms of space and time.
This article is contributed by Aarti_Rathi. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!