# Smallest missing non-negative integer upto every array index

Given an array arr[] of size N, the task is for every array indices is to find the smallest missing non-negative integer upto that index of the given array.

Examples:

Input: arr[] = {1, 3, 0, 2}
Output: 0 0 2 4
Explanation:
Smallest missing non-negative integer from index 0 to 0 is 0.
Smallest missing non-negative integer from index 0 to 1 is 0.
Smallest missing non-negative integer from index 0 to 2 is 2.
Smallest missing non-negative integer from index 0 to 3 is 4.

Input: arr[] = {0, 1, 2, 3, 5}
Output: 1 2 3 4 4

Approach: This problem can be solved using Hashing. Follow the steps below to solve the problem:

• Initialize a variable, say smNonNeg to store the smallest missing non-negative integers between the start index and the current index of the given array.
• Initialize an array, say hash[N] to check if smNonNeg present between the start index and the current index or not.
• Traverse the given array and check if hash[smNonNeg] equal to 0 or not. If found to be true, then print the value of smNonNeg.
• Otherwise, increment the value of smNonNeg while hash[smNonNeg] not equal to 0.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement` `// the above approach`   `#include ` `using` `namespace` `std;`   `// Function to print the smallest` `// missing non-negative integer` `// up to every array indices` `void` `smlstNonNeg(``int` `arr[], ``int` `N)` `{` `    ``// Stores the smallest missing` `    ``// non-negative integers between` `    ``// start index to current index` `    ``int` `smNonNeg = 0;`   `    ``// Store the boolean value to check` `    ``// smNonNeg present between start` `    ``// index to each index of the array` `    ``bool` `hash[N + 1] = { 0 };`   `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < N; i++) {`   `        ``// Since output always lies` `        ``// in the range[0, N - 1]` `        ``if` `(arr[i] >= 0 and arr[i] < N) {` `            ``hash[arr[i]] = ``true``;` `        ``}`   `        ``// Check if smNonNeg is` `        ``// present between start index` `        ``// and current index or not` `        ``while` `(hash[smNonNeg]) {` `            ``smNonNeg++;` `        ``}`   `        ``// Print smallest missing` `        ``// non-negative integer` `        ``cout << smNonNeg << ``" "``;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 0, 1, 2, 3, 5 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``smlstNonNeg(arr, N);` `}`

## Java

 `// Java program to implement` `// the above approach` `import` `java.io.*;` `import` `java.util.Arrays;`   `class` `GFG{` ` `  `// Function to print the smallest` `// missing non-negative integer` `// up to every array indices` `static` `void` `smlstNonNeg(``int` `arr[], ``int` `N)` `{` `    `  `    ``// Stores the smallest missing` `    ``// non-negative integers between` `    ``// start index to current index` `    ``int` `smNonNeg = ``0``;` ` `  `    ``// Store the boolean value to check` `    ``// smNonNeg present between start` `    ``// index to each index of the array` `    ``Boolean[] hash = ``new` `Boolean[N + ``1``];` `    ``Arrays.fill(hash, ``false``);`   `    ``// Traverse the array` `    ``for``(``int` `i = ``0``; i < N; i++)` `    ``{` `        `  `        ``// Since output always lies` `        ``// in the range[0, N - 1]` `        ``if` `(arr[i] >= ``0` `&& arr[i] < N)` `        ``{` `            ``hash[arr[i]] = ``true``;` `        ``}` ` `  `        ``// Check if smNonNeg is` `        ``// present between start index` `        ``// and current index or not` `        ``while` `(hash[smNonNeg]) ` `        ``{` `            ``smNonNeg++;` `        ``}` ` `  `        ``// Print smallest missing` `        ``// non-negative integer` `        ``System.out.print(smNonNeg + ``" "``);` `    ``}` `}` ` `  `// Driver Code` `public` `static` `void` `main (String[] args)` `{` `    ``int` `arr[] = { ``0``, ``1``, ``2``, ``3``, ``5` `};` `    ``int` `N = arr.length;` `    `  `    ``smlstNonNeg(arr, N);` `}` `}`   `// This code is contributed by sanjoy_62`

## Python3

 `# Python3 program to implement` `# the above approach`   `# Function to prthe smallest` `# missing non-negative integer` `# up to every array indices` `def` `smlstNonNeg(arr, N):` `    `  `    ``# Stores the smallest missing` `    ``# non-negative integers between` `    ``# start index to current index` `    ``smNonNeg ``=` `0`   `    ``# Store the boolean value to check` `    ``# smNonNeg present between start` `    ``# index to each index of the array` `    ``hash` `=` `[``0``] ``*` `(N ``+` `1``)`   `    ``# Traverse the array` `    ``for` `i ``in` `range``(N):`   `        ``# Since output always lies` `        ``# in the range[0, N - 1]` `        ``if` `(arr[i] >``=` `0` `and` `arr[i] < N):` `            ``hash``[arr[i]] ``=` `True`   `        ``# Check if smNonNeg is` `        ``# present between start index` `        ``# and current index or not` `        ``while` `(``hash``[smNonNeg]):` `            ``smNonNeg ``+``=` `1`   `        ``# Print smallest missing` `        ``# non-negative integer` `        ``print``(smNonNeg, end ``=` `" "``)`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``arr ``=` `[ ``0``, ``1``, ``2``, ``3``, ``5` `]` `    ``N ``=` `len``(arr)` `    `  `    ``smlstNonNeg(arr, N)`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# program to implement` `// the above approach` `using` `System;` ` `  `class` `GFG{` `  `  `// Function to print the smallest` `// missing non-negative integer` `// up to every array indices` `static` `void` `smlstNonNeg(``int``[] arr, ``int` `N)` `{` `    `  `    ``// Stores the smallest missing` `    ``// non-negative integers between` `    ``// start index to current index` `    ``int` `smNonNeg = 0;` `  `  `    ``// Store the boolean value to check` `    ``// smNonNeg present between start` `    ``// index to each index of the array` `    ``bool``[] hash = ``new` `bool``[N + 1];` `    `  `    ``for``(``int` `i = 0; i < N; i++)` `    ``{` `        ``hash[i] = ``false``;` `    ``}` `    `  `    ``// Traverse the array` `    ``for``(``int` `i = 0; i < N; i++)` `    ``{` `        `  `        ``// Since output always lies` `        ``// in the range[0, N - 1]` `        ``if` `(arr[i] >= 0 && arr[i] < N)` `        ``{` `            ``hash[arr[i]] = ``true``;` `        ``}` `  `  `        ``// Check if smNonNeg is` `        ``// present between start index` `        ``// and current index or not` `        ``while` `(hash[smNonNeg]) ` `        ``{` `            ``smNonNeg++;` `        ``}` `  `  `        ``// Print smallest missing` `        ``// non-negative integer` `        ``Console.Write(smNonNeg + ``" "``);` `    ``}` `}` `  `  `// Driver Code` `public` `static` `void` `Main ()` `{` `    ``int``[] arr = { 0, 1, 2, 3, 5 };` `    ``int` `N = arr.Length;` `     `  `    ``smlstNonNeg(arr, N);` `}` `}`   `// This code is contributed by code_hunt`

Output:

```1 2 3 4 4

```

Time Complexity: O(N)
Auxiliary Space: 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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.