Related Articles
Rearrange an array such that arr[i] = i
• Difficulty Level : Easy
• Last Updated : 26 Mar, 2021

Given an array of elements of length N, ranging from 0 to N – 1. All elements may not be present in the array. If the element is not present then there will be -1 present in the array. Rearrange the array such that A[i] = i and if i is not present, display -1 at that place.

Examples:

```Input : arr = {-1, -1, 6, 1, 9, 3, 2, -1, 4, -1}
Output : [-1, 1, 2, 3, 4, -1, 6, -1, -1, 9]

Input : arr = {19, 7, 0, 3, 18, 15, 12, 6, 1, 8,
11, 10, 9, 5, 13, 16, 2, 14, 17, 4}
Output : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19]```

Approach(Naive Approach):

1. Nav­i­gate the numbers from 0 to n-1.
2. Now navigate through array.
3. If (i==a[j]) , then replace the element at i position with a[j] position.
4. If there is any element in which -1 is used instead of the number then it will be replaced automatically.
5. Now, iterate through the array and check if (a[i]!=i) , if it s true then replace a[i] with -1.

Below is the implementation for the above approach:

## C++

 `// C++ program for above approach``#include ``using` `namespace` `std;` `// Function to tranform the array``void` `fixArray(``int` `ar[], ``int` `n)``{``    ``int` `i, j, temp;` `    ``// Iterate over the array``    ``for` `(i = 0; i < n; i++)``    ``{``        ``for` `(j = 0; j < n; j++)``        ``{``            ``// Checf is any ar[j]``            ``// exists such that``            ``// ar[j] is equal to i``            ``if` `(ar[j] == i) {``                ``temp = ar[j];``                ``ar[j] = ar[i];``                ``ar[i] = temp;``                ``break``;``            ``}``        ``}``    ``}` `    ``// Iterate over array``    ``for` `(i = 0; i < n; i++)``    ``{``        ``// If not present``        ``if` `(ar[i] != i)``        ``{``            ``ar[i] = -1;``        ``}``    ``}` `    ``// Print the output``    ``cout << ``"Array after Rearranging"` `<< endl;``    ``for` `(i = 0; i < n; i++) {``        ``cout << ar[i] << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `n, ar[] = { -1, -1, 6, 1, 9, 3, 2, -1, 4, -1 };``    ``n = ``sizeof``(ar) / ``sizeof``(ar[0]);` `    ``// Function Call``    ``fixArray(ar, n);``}` `// Code BY Tanmay Anand`

## Java

 `// Java program for above approach``class` `GFG{``    ` `// Function to tranform the array``public` `static` `void` `fixArray(``int` `ar[], ``int` `n)``{``    ``int` `i, j, temp;``    ` `    ``// Iterate over the array``    ``for``(i = ``0``; i < n; i++)``    ``{``        ``for``(j = ``0``; j < n; j++)``        ``{``            ` `            ``// Checf is any ar[j]``            ``// exists such that``            ``// ar[j] is equal to i``            ``if` `(ar[j] == i)``            ``{``                ``temp = ar[j];``                ``ar[j] = ar[i];``                ``ar[i] = temp;``                ``break``;``            ``}``        ``}``    ``}`` ` `    ``// Iterate over array``    ``for``(i = ``0``; i < n; i++)``    ``{``        ` `        ``// If not present``        ``if` `(ar[i] != i)``        ``{``            ``ar[i] = -``1``;``        ``}``    ``}`` ` `    ``// Print the output``    ``System.out.println(``"Array after Rearranging"``);``    ``for``(i = ``0``; i < n; i++)``    ``{``        ``System.out.print(ar[i] + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `n, ar[] = { -``1``, -``1``, ``6``, ``1``, ``9``,``                     ``3``, ``2``, -``1``, ``4``, -``1` `};``    ``n = ar.length;`` ` `    ``// Function Call``    ``fixArray(ar, n);``}``}` `// This code is contributed by divyesh072019`

## Python3

 `# Python3 program for above approach` `# Function to tranform the array``def` `fixArray(ar, n):``    ` `    ``# Iterate over the array``    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(n):` `            ``# Check is any ar[j]``            ``# exists such that``            ``# ar[j] is equal to i``            ``if` `(ar[j] ``=``=` `i):``                ``ar[j], ar[i] ``=` `ar[i], ar[j]` `    ``# Iterate over array``    ``for` `i ``in` `range``(n):``        ` `        ``# If not present``        ``if` `(ar[i] !``=` `i):``            ``ar[i] ``=` `-``1` `    ``# Print the output``    ``print``(``"Array after Rearranging"``)` `    ``for` `i ``in` `range``(n):``        ``print``(ar[i], end ``=` `" "``)` `# Driver Code``ar ``=` `[ ``-``1``, ``-``1``, ``6``, ``1``, ``9``, ``3``, ``2``, ``-``1``, ``4``, ``-``1` `]``n ``=` `len``(ar)` `# Function Call``fixArray(ar, n);` `# This code is contributed by rag2127`

## C#

 `// C# program for above approach``using` `System;``class` `GFG {``    ` `    ``// Function to tranform the array``    ``static` `void` `fixArray(``int``[] ar, ``int` `n)``    ``{``        ``int` `i, j, temp;``         ` `        ``// Iterate over the array``        ``for``(i = 0; i < n; i++)``        ``{``            ``for``(j = 0; j < n; j++)``            ``{``                 ` `                ``// Checf is any ar[j]``                ``// exists such that``                ``// ar[j] is equal to i``                ``if` `(ar[j] == i)``                ``{``                    ``temp = ar[j];``                    ``ar[j] = ar[i];``                    ``ar[i] = temp;``                    ``break``;``                ``}``            ``}``        ``}``      ` `        ``// Iterate over array``        ``for``(i = 0; i < n; i++)``        ``{``             ` `            ``// If not present``            ``if` `(ar[i] != i)``            ``{``                ``ar[i] = -1;``            ``}``        ``}``      ` `        ``// Print the output``        ``Console.WriteLine(``"Array after Rearranging"``);``        ``for``(i = 0; i < n; i++)``        ``{``            ``Console.Write(ar[i] + ``" "``);``        ``}``    ``} ``    ` `  ``static` `void` `Main() {``        ``int``[] ar = { -1, -1, 6, 1, 9,``                     ``3, 2, -1, 4, -1 };``        ``int` `n = ar.Length;``      ` `        ``// Function Call``        ``fixArray(ar, n);``  ``}``}` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``
Output

```Array after Rearranging
-1 1 2 3 4 -1 6 -1 -1 9```

Time Complexity: O(n2)

Another Approach:
1. Nav­i­gate through the array.
2. Check if a[i] = -1, if yes then ignore it.
3. If a[i] != -1, Check if element a[i] is at its cor­rect posi­tion (i=A[i]). If yes then ignore it.
4. If a[i] != -1 and ele­ment a[i] is not at its cor­rect posi­tion (i!=A[i]) then place it to its correct posi­tion, but there are two conditions:

• Either A[i] is vacate, means A[i] = -1, then just put A[i] = i .
• OR A[i] is not vacate, means A[i] = x, then int y=x put A[i] = i. Now, we need to place y to its cor­rect place, so repeat from step 3.

Below is the implementation for the above approach:

## C++

 `// C++ program for rearrange an``// array such that arr[i] = i.``#include ` `using` `namespace` `std;` `// Function to rearrange an array``// such that arr[i] = i.``void` `fixArray(``int` `A[], ``int` `len)``{``    ``for` `(``int` `i = 0; i < len; i++)``    ``{``        ``if` `(A[i] != -1 && A[i] != i)``        ``{``            ``int` `x = A[i];` `            ``// check if desired place``            ``// is not vacate``            ``while` `(A[x] != -1 && A[x] != x)``            ``{``                ``// store the value from``                ``// desired place``                ``int` `y = A[x];` `                ``// place the x to its correct``                ``// position``                ``A[x] = x;` `                ``// now y will become x, now``                ``// search the place for x``                ``x = y;``            ``}` `            ``// place the x to its correct``            ``// position``            ``A[x] = x;` `            ``// check if while loop hasn't``            ``// set the correct value at A[i]``            ``if` `(A[i] != i)``            ``{``                ``// if not then put -1 at``                ``// the vacated place``                ``A[i] = -1;``            ``}``        ``}``    ``}``}` `// Driver code``int` `main()``{``    ``int` `A[] = { -1, -1, 6, 1, 9,``               ``3, 2, -1, 4, -1 };` `    ``int` `len = ``sizeof``(A) / ``sizeof``(A[0]);` `    ``// Function Call``    ``fixArray(A, len);` `    ``// Print the output``    ``for` `(``int` `i = 0; i < len; i++)``        ``cout << A[i] << ``" "``;``}` `// This code is contributed by Smitha Dinesh Semwal`

## Java

 `// Java program for rearrange an``// array such that arr[i] = i.``import` `java.util.*;``import` `java.lang.*;` `public` `class` `GfG {` `    ``// Function to rearrange an array``    ``// such that arr[i] = i.``    ``public` `static` `int``[] fix(``int``[] A)``    ``{``        ``for` `(``int` `i = ``0``; i < A.length; i++)``        ``{``            ``if` `(A[i] != -``1` `&& A[i] != i)``            ``{``                ``int` `x = A[i];` `                ``// check if desired place``                ``// is not vacate``                ``while` `(A[x] != -``1` `&& A[x] != x)``                ``{``                    ``// store the value from``                    ``// desired place``                    ``int` `y = A[x];` `                    ``// place the x to its correct``                    ``// position``                    ``A[x] = x;` `                    ``// now y will become x, now``                    ``// search the place for x``                    ``x = y;``                ``}` `                ``// place the x to its correct``                ``// position``                ``A[x] = x;` `                ``// check if while loop hasn't``                ``// set the correct value at A[i]``                ``if` `(A[i] != i)``                ``{``                    ``// if not then put -1 at``                    ``// the vacated place``                    ``A[i] = -``1``;``                ``}``            ``}``        ``}``        ``return` `A;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `A[] = { -``1``, -``1``, ``6``, ``1``, ``9``, ``3``, ``2``, -``1``, ``4``, -``1` `};``        ``System.out.println(Arrays.toString(fix(A)));``    ``}``}`

## Python3

 `# Python3 program for rearrange an``# array such that arr[i] = i.` `# Function to rearrange an array``# such that arr[i] = i.`  `def` `fix(A, ``len``):` `    ``for` `i ``in` `range``(``0``, ``len``):` `        ``if` `(A[i] !``=` `-``1` `and` `A[i] !``=` `i):``            ``x ``=` `A[i]` `            ``# check if desired place``            ``# is not vacate``            ``while` `(A[x] !``=` `-``1` `and` `A[x] !``=` `x):``                ` `                ``# store the value from``                ``# desired place``                ``y ``=` `A[x]` `                ``# place the x to its correct``                ``# position``                ``A[x] ``=` `x` `                ``# now y will become x, now``                ``# search the place for x``                ``x ``=` `y` `            ``# place the x to its correct``            ``# position``            ``A[x] ``=` `x` `            ``# check if while loop hasn't``            ``# set the correct value at A[i]``            ``if` `(A[i] !``=` `i):` `                ``# if not then put -1 at``                ``# the vacated place``                ``A[i] ``=` `-``1`  `# Driver code``A ``=` `[``-``1``, ``-``1``, ``6``, ``1``, ``9``, ``3``, ``2``, ``-``1``, ``4``, ``-``1``]` `fix(A, ``len``(A))` `for` `i ``in` `range``(``0``, ``len``(A)):``    ``print``(A[i], end``=``' '``)` `# This code is contributed by Saloni1297`

## C#

 `// C# program for rearrange``// an array such that``// arr[i] = i.``using` `System;` `class` `GfG {``    ``// Function to rearrange an``    ``// array such that arr[i] = i.``    ``public` `static` `int``[] fix(``int``[] A)``    ``{``        ``for` `(``int` `i = 0; i < A.Length; i++)``        ``{``            ``if` `(A[i] != -1 && A[i] != i)``            ``{``                ``int` `x = A[i];` `                ``// check if desired``                ``// place is not vacate``                ``while` `(A[x] != -1 && A[x] != x)``                ``{``                    ``// store the value``                    ``// from desired place``                    ``int` `y = A[x];` `                    ``// place the x to its``                    ``// correct position``                    ``A[x] = x;` `                    ``// now y will become x,``                    ``// now search the place``                    ``// for x``                    ``x = y;``                ``}` `                ``// place the x to its``                ``// correct position``                ``A[x] = x;` `                ``// check if while loop``                ``// hasn't set the correct``                ``// value at A[i]``                ``if` `(A[i] != i)``                ``{``                    ``// if not then put -1``                    ``// at the vacated place``                    ``A[i] = -1;``                ``}``            ``}``        ``}``        ``return` `A;``    ``}` `    ``// Driver Code``    ``static` `void` `Main()``    ``{``        ``int``[] A = ``new` `int``[] { -1, -1, 6,  1, 9,``                              ``3,  2,  -1, 4, -1 };``        ``Console.WriteLine(``string``.Join(``","``, fix(A)));``    ``}``}` `// This code is contributed by``// Manish Shaw(manishshaw1)`

## PHP

 ``
Output
`-1 1 2 3 4 -1 6 -1 -1 9`

Another Approach (Using HashSet) :
1) Store all the numbers present in the array into a HashSet
2) Iterate through the length of the array, if the corresponding position element is present in the HashSet, then set A[i] = i, else A[i] = -1

Below is the implementation of the above approach.

## C++

 `#include ``#include ` `using` `namespace` `std;` `//``void` `fixArray(``int` `arr[], ``int` `n)``{``  ``// Initialize a hashmap``  ``std::unordered_map<``int``, ``int``> hmap;``  ` `  ``// Enter each element in hmap``  ``for``(``int` `i{0}; i

## Java

 `// Java program for rearrange an``// array such that arr[i] = i.``import` `java.util.*;``import` `java.lang.*;` `class` `GfG {` `    ``// Function to rearrange an array``    ``// such that arr[i] = i.``    ``public` `static` `int``[] fix(``int``[] A)``    ``{``        ``Set s = ``new` `HashSet();` `        ``// Storing all the values in the HashSet``        ``for``(``int` `i = ``0``; i < A.length; i++)``        ``{``           ``s.add(A[i]);``        ``}` `        ``for``(``int` `i = ``0``; i < A.length; i++)``        ``{``           ``if``(s.contains(i))``             ``A[i] = i;``           ``else``             ``A[i] = -``1``;``        ``}` `      ``return` `A;``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `A[] = {-``1``, -``1``, ``6``, ``1``, ``9``,``                    ``3``, ``2``, -``1``, ``4``,-``1``};``                    ` `        ``// Function calling``        ``System.out.println(Arrays.toString(fix(A)));``    ``}``}`

## Python3

 `# Python3 program for rearrange an``# array such that arr[i] = i.` `# Function to rearrange an array``# such that arr[i] = i.``def` `fix(A):``    ``s ``=` `set``()``    ` `    ``# Storing all the values in the Set``    ``for` `i ``in` `range``(``len``(A)):``        ``s.add(A[i])` `    ``for` `i ``in` `range``(``len``(A)):``      ` `        ``# check for item if present in set``        ``if` `i ``in` `s:``            ``A[i] ``=` `i``        ``else``:``            ``A[i] ``=` `-``1``    ``return` `A``    ` `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ``A ``=` `[``-``1``, ``-``1``, ``6``, ``1``, ``9``,``          ``3``, ``2``, ``-``1``, ``4``,``-``1``]``    ``print``(fix(A))` `# This code is contributed by Chitranayal`

## C#

 `// C# program for rearrange an``// array such that arr[i] = i.``using` `System;` `class` `GfG``{` `    ``// Function to rearrange``    ``// an array such that``    ``// arr[i] = i.``    ``static` `int``[] fix(``int` `[]A)``    ``{``        ``for` `(``int` `i = 0;``                 ``i < A.Length; i++)``        ``{``            ``if` `(A[i] != -1 &&``                ``A[i] != i)``            ``{``                ``int` `x = A[i];` `                ``// check if desired place``                ``// is not vacate``                ``while` `(A[x] != -1 &&``                       ``A[x] != x)``                ``{` `                    ``// store the value from``                    ``// desired place``                    ``int` `y = A[x];` `                    ``// place the x to its``                    ``// correct position``                    ``A[x] = x;` `                    ``// now y will become x, now``                    ``// search the place for x``                    ``x = y;``                ``}` `                ``// place the x to its``                ``// correct position``                ``A[x] = x;` `                ``// check if while loop hasn't``                ``// set the correct value at A[i]``                ``if` `(A[i] != i)``                ``{``                    ``// if not then put -1 at``                    ``// the vacated place``                    ``A[i] = -1;``                ``}``            ``}``        ``}``        ``return` `A;``    ``}``    ` `    ``// Driver Code``    ``static` `void` `Main()``    ``{``        ``int` `[]A = ``new` `int``[]{-1, -1, 6, 1, 9,``                             ``3, 2, -1, 4,-1};``        ``Console.Write(``string``.Join(``","``, fix(A)));``    ``}``}` `// This code is contributed by``// Manish Shaw(manishshaw1)`
Output
`-1 1 2 3 4 -1 6 -1 -1 9`

Another Approach (Swap elements in Array) :
1) Iterate through elements in an array
2) If arr[i] >= 0 && arr[i] != i, put arr[i] at i ( swap arr[i] with arr[arr[i]])

Below is the implementation of above approach.

## C++

 `// C++ program for rearrange an``// array such that arr[i] = i.``#include ` `void` `fixArray(``int` `arr[], ``int` `n)``{` `    ``for` `(``int` `i = 0; i < n;)``    ``{``        ``if` `(arr[i] >= 0 && arr[i] != i)``            ``arr[arr[i]] = (arr[arr[i]] + arr[i])``                          ``- (arr[i] = arr[arr[i]]);``        ``else``            ``i++;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { -1, -1, 6, 1, 9, 3, 2, -1, 4, -1 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// Fucnction Call``    ``fixArray(arr, n);` `    ``// Print output``    ``for` `(``int` `i = 0; i < n; i++)``        ``printf``(``"%d "``, arr[i]);``    ``return` `0;``}` `// This Code is Contributed by Adarsh_Verma`

## Java

 `// Java program for rearrange an``// array such that arr[i] = i.``import` `java.util.Arrays;` `class` `Program``{``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] arr = { -``1``, -``1``, ``6``, ``1``, ``9``, ``3``, ``2``, -``1``, ``4``, -``1` `};``        ``for` `(``int` `i = ``0``; i < arr.length;)``        ``{``            ``if` `(arr[i] >= ``0` `&& arr[i] != i)``            ``{``                ``int` `ele = arr[arr[i]];``                ``arr[arr[i]] = arr[i];``                ``arr[i] = ele;``            ``}``            ``else``            ``{``                ``i++;``            ``}``        ``}``        ``System.out.println(Arrays.toString(arr));``    ``}``}` `/* This Java code is contributed by PrinciRaj1992*/`

## Python3

 `# Python3 program for rearrange an``# array such that arr[i] = i.``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``-``1``, ``-``1``, ``6``, ``1``, ``9``,``           ``3``, ``2``, ``-``1``, ``4``, ``-``1``]``    ``n ``=` `len``(arr)``    ``i ``=` `0``    ``while` `i < n:` `        ``if` `(arr[i] >``=` `0` `and` `arr[i] !``=` `i):``            ``(arr[arr[i]],``             ``arr[i]) ``=` `(arr[i],``                        ``arr[arr[i]])``        ``else``:``            ``i ``+``=` `1` `    ``for` `i ``in` `range``(n):``        ``print``(arr[i], end``=``" "``)` `# This code is contributed by Chitranayal`

## C#

 `// C# program for rearrange an``// array such that arr[i] = i.``using` `System;` `namespace` `GFG {` `class` `Program {``    ``static` `void` `Main(``string``[] args)``    ``{``        ``int``[] arr = { -1, -1, 6, 1, 9,``                     ``3, 2, -1, 4, -1 };``        ``for` `(``int` `i = 0; i < arr.Length;)``        ``{``            ``if` `(arr[i] >= 0 && arr[i] != i)``            ``{``                ``int` `ele = arr[arr[i]];``                ``arr[arr[i]] = arr[i];``                ``arr[i] = ele;``            ``}``            ``else``            ``{``                ``i++;``            ``}``        ``}``        ``Console.WriteLine(String.Join(``","``, arr));``    ``}``}``}``// This code is contributed by``// Venkata VardhiReddy(venkata)`
Output
`-1 1 2 3 4 -1 6 -1 -1 9`

Time Complexity: O(n)

My Personal Notes arrow_drop_up