# Smallest missing non-negative integer upto every array index

• Difficulty Level : Medium
• Last Updated : 10 Nov, 2021

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

## Javascript

 ``

Output:

`1 2 3 4 4`

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

My Personal Notes arrow_drop_up