Open in App
Not now

# Reorder an array according to given indexes

• Difficulty Level : Medium
• Last Updated : 19 Dec, 2022

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

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

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

## PHP

 ``

## Javascript

 ``

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

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

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

## Javascript

 ``

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

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

 ``

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

 ``

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 ` `#include ` `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.`

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.