Related Articles

# Rearrange an array such that arr[i] = i

• Difficulty Level : Easy
• Last Updated : 15 Jul, 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 transform 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++)``        ``{``            ``// Check 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);` `    ``// Function Call``    ``fixArray(ar, n);``}` `// Code BY Tanmay Anand`

## Java

 `// Java program for above approach``class` `GFG{``    ` `// Function to transform 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++)``        ``{``            ` `            ``// Check 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 transform 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 transform 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++)``            ``{``                 ` `                ``// Check 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);` `    ``// 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

 ``

## Javascript

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

 `using` `System;``using` `System.Collections.Generic;``public` `class` `main{``    ``static` `void` `fix(``int``[] a,``int` `n){``       ``HashSet<``int``> hs=``new` `HashSet<``int``>();``        ` `        ``// Traverse the array``        ``// and add each element``        ``// to the HashSet``        ``for``(``int` `i=0;i i=n-1``        ``for``(``int` `i=0;i

## Javascript

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

## Javascript

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

Time Complexity: O(n)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up