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

// 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[]{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(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[]{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(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(n²) 
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(N), as we are performing cyclic sort which has a time complexity of O(N)
Auxiliary Space: O(1), since no extra space has been taken.

Better Approach

1. Calculate the max(array, n) and value=max_value + 1; This is needed to identify the upper range of values present in the array as the modulus operation will always return a value from 0 to N-1  (used in next step for storing two elements together)
2. For each element, place the element at index=i at it’s desired position at index=j such that it’s possible to retrieve both elements when needed. The following formula has been used to store the array[i] at array[j]

array[index[i]] = (array[index[i]] + array[i]%value*value)

3. Once the elements are placed at each position, traverse the array once and update each element by element/value.

C++

// C++ code for the above approach
#include <climits>
#include <iostream>
using namespace std;

void printArray(int arr[], int n)
{
  for (int i = 0; i < n; i++)
    cout << arr[i] << " ";
}

int findMax(int arr[], int n)
{
  int Max = INT_MIN;
  for (int i = 0; i < n; i++) {
    if (Max < arr[i])
      Max = arr[i];
  }
  return Max;
}

// result = (original + update%z*z)  ..
void rearrange(int arr[], int index[], int n)
{
  int z = findMax(arr, n) + 1;
  for (int i = 0; i < n; i++) {
    arr[index[i]] = arr[index[i]] % z + arr[i] % z * z;
  }
  for (int i = 0; i < n; i++) {
    arr[i] = arr[i] / z;
  }
}

int main()
{
  int arr[] = { 23, 12, 20, 10, 23 };
  int index[] = { 4, 0, 1, 2, 3 };

  rearrange(arr, index, 5);
  printArray(arr, 5);

  return 0;
}

// This code is contributed by lokesh

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int arr[] = { 23, 12, 20, 10, 23 };
        int index[] = { 4, 0, 1, 2, 3 };

        rearrange(arr, index);
        printArray(arr);
    }
    private static void printArray(int arr[])
    {
        for (int i = 0; i < arr.length; i++)
            System.out.print(arr[i] + " ");
    }
    //    result = (original + update%z*z)  ..
    private static void rearrange(int[] arr, int[] index)
    {
        int z = findMax(arr) + 1;
        for (int i = 0; i < arr.length; i++) {
            arr[index[i]]
                = arr[index[i]] % z + arr[i] % z * z;
        }
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] / z;
        }
    }

    private static int findMax(int[] arr)
    {
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i])
                max = arr[i];
        }
        return max;
    }
}

Python3

# Python implementation for the above approach
def printArray(arr):
    for i in range(len(arr)):
        print(arr[i], end=" ")

# result = (original + update%z*z) ..
def rearrange(arr, index):
    z = findMax(arr) + 1
    for i in range(len(arr)):
        arr[index[i]] = arr[index[i]] % z + arr[i] % z * z

    for i in range(len(arr)):
        arr[i] = arr[i]//z


def findMax(arr):
    Max = float("-inf")
    for i in range(len(arr)):
        if(Max < arr[i]):
            Max = arr[i]

    return Max

arr = [23, 12, 20, 10, 23]
index = [4, 0, 1, 2, 3]

rearrange(arr, index)
printArray(arr)

# This code is contributed by lokesh

C#

// C# implementation for the above approach
using System;

public class GFG {

    static public void Main()
    {

        // Code
        int[] arr = { 23, 12, 20, 10, 23 };
        int[] index = { 4, 0, 1, 2, 3 };

        rearrange(arr, index);
        printArray(arr);
    }

    private static void printArray(int[] arr)
    {
        for (int i = 0; i < arr.Length; i++)
            Console.Write(arr[i] + " ");
    }
    //    result = (original + update%z*z)  ..
    private static void rearrange(int[] arr, int[] index)
    {
        int z = findMax(arr) + 1;
        for (int i = 0; i < arr.Length; i++) {
            arr[index[i]]
                = arr[index[i]] % z + arr[i] % z * z;
        }
        for (int i = 0; i < arr.Length; i++) {
            arr[i] = arr[i] / z;
        }
    }

    private static int findMax(int[] arr)
    {
        int max = Int32.MinValue;
        for (int i = 0; i < arr.Length; i++) {
            if (max < arr[i])
                max = arr[i];
        }
        return max;
    }
}

// This code is contributed by lokeshmvs21.

Javascript

// JavaScript implementation for the above approach

function printArray(){
    for(let i = 0; i < arr.length; i++){
        console.log(Math.trunc(arr[i]) + " ");
    }
}

//    result = (original + update%z*z)  ..
function rearrange(arr, index){
    var z = findMax(arr) + 1;
    for(let i = 0; i < arr.length; i++){
        arr[index[i]] = arr[index[i]] % z + arr[i] % z * z;
    }
    for(let i = 0; i < arr.length; i++){
        arr[i] = arr[i]/z;
    }
}

function findMax(arr){
    let max = Number.MIN_VALUE;
    for(let i = 0; i < arr.length; i++){
        if(max < arr[i]){
            max = arr[i];
        }
    }
    return max;
}

let arr = [ 23, 12, 20, 10, 23 ];
let index = [ 4, 0, 1, 2, 3 ];

rearrange(arr, index);
printArray(arr);

// This code is contributed by lokeshmvs21.

Output

12 20 10 23 23 

Time Complexity: O(N)
Space Complexity: O(1)

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