# Find the smallest positive number missing from an unsorted array : Hashing Implementation

Given an unsorted array with both positive and negative elements including 0. The task is to find the smallest positive number missing from the array in O(N) time.

Examples:

```Input: arr[] = {-5, 2, 0, -1, -10, 15}
Output: 1

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

Input: arr[] = {1, 1, 1, 0, -1, -2}
Output: 2
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

We can use hashing to solve this problem. The idea is to build a hash table of all positive elements in the given array. Once the hash table is built. We can look in the hash table for all positive integers, starting from 1. As soon as we find a number which is not there in the hash table, we return it.

We can use the unordered_map in C++ to implement the hash which allow to perform look up operation in almost O(1) time complexity.

Below is the implementation of the above approach:

## C++

 `// C++ program to find the smallest ` `// positive missing number ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Function to find the smallest positive ` `// missing number ` `int` `missingNumber(``int` `a[], ``int` `n) ` `{ ` `    ``// Declaring an unordered_map ` `    ``unordered_map<``int``, ``int``> mp; ` ` `  `    ``// if array value is positive ` `    ``// store it in map ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``if` `(a[i] > 0) ` `            ``mp[a[i]]++; ` `    ``} ` ` `  `    ``// index value set to 1 ` `    ``int` `index = 1; ` ` `  `    ``// Return the first value starting ` `    ``// from 1 which does not exists in map ` `    ``while` `(1) { ` `        ``if` `(mp.find(index) == mp.end()) { ` `            ``return` `index; ` `        ``} ` ` `  `        ``index++; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `a[] = { 1, 1, 1, 0, -1, -2 }; ` `    ``int` `size = ``sizeof``(a) / ``sizeof``(a); ` ` `  `    ``cout << ``"Smallest positive missing number is : "` `         ``<< missingNumber(a, size) << endl; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to find the smallest  ` `// positive missing number  ` ` `  `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``// Function to find the smallest positive  ` `    ``// missing number  ` `    ``static` `int` `missingNumber(``int` `a[], ``int` `n)  ` `    ``{ ` `        ``// Declaring an unordered_map  ` `        ``Map mp = ``new` `LinkedHashMap<>(); ` ` `  `        ``// if array value is positive  ` `        ``// store it in map  ` `        ``for` `(``int` `i = ``0``; i < n; i++)  ` `        ``{ ` `            ``if` `(a[i] > ``0``)  ` `            ``{ ` `                ``mp.put(a[i], mp.get(a[i]) == ``null` `? ``1` `: mp.get(a[i]) + ``1``); ` `            ``} ` `        ``} ` ` `  `        ``// index value set to 1  ` `        ``int` `index = ``1``; ` ` `  `        ``// Return the first value starting  ` `        ``// from 1 which does not exists in map  ` `        ``while` `(``true``)  ` `        ``{ ` `            ``if` `(!mp.containsKey(index))  ` `            ``{ ` `                ``return` `index; ` `            ``} ` ` `  `            ``index++; ` `        ``} ` `    ``} ` ` `  `    ``// Driver code  ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``int` `a[] = {``1``, ``1``, ``1``, ``0``, -``1``, -``2``}; ` `        ``int` `size = a.length; ` ` `  `        ``System.out.println(``"Smallest positive missing number is : "` `                ``+ missingNumber(a, size)); ` `    ``} ` `} ` ` `  `// This code has been contributed by 29AjayKumar `

## Python3

 `# Python3 program to find the smallest  ` `# positive missing number  ` ` `  `# Function to find the smallest positive  ` `# missing number  ` `def` `missingNumber(a, n) :  ` `     `  `    ``# Declaring an unordered_map  ` `    ``mp ``=` `dict``();  ` ` `  `    ``# if array value is positive  ` `    ``# store it in map  ` `    ``for` `i ``in` `range``(n) : ` `        ``if` `(a[i] > ``0``) : ` `            ``if` `a[i] ``not` `in` `mp.keys() : ` `                ``mp[a[i]] ``=` `0` `           `  `            ``mp[a[i]] ``+``=` `1` ` `  `    ``# index value set to 1  ` `    ``index ``=` `1``;  ` ` `  `    ``# Return the first value starting  ` `    ``# from 1 which does not exists in map  ` `    ``while` `(``1``) : ` `        ``if` `(index ``not` `in` `mp.keys()) :  ` `            ``return` `index;  ` `         `  ` `  `        ``index ``+``=` `1``;  ` ` `  ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` ` `  `    ``a ``=` `[ ``1``, ``1``, ``1``, ``0``, ``-``1``, ``-``2` `];  ` `    ``size ``=` `len``(a);  ` ` `  `    ``print``(``"Smallest positive missing number is : "``,missingNumber(a, size));  ` ` `  `# This code is contributed by AnkitRai01 `

## C#

 `// C# program to find the smallest  ` `// positive missing number  ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``// Function to find the smallest positive  ` `    ``// missing number  ` `    ``static` `int` `missingNumber(``int` `[]a, ``int` `n)  ` `    ``{ ` `        ``// Declaring an unordered_map  ` `        ``Dictionary<``int``,``int``> m = ``new` `Dictionary<``int``,``int``>(); ` ` `  `        ``// if array value is positive  ` `        ``// store it in map  ` `        ``for` `(``int` `i = 0; i < n; i++)  ` `        ``{ ` `            ``if` `(a[i] > 0)  ` `            ``{ ` `                ``if``(m.ContainsKey(a[i])) ` `                ``{ ` `                    ``var` `val = m[a[i]]; ` `                    ``m.Remove(a[i]); ` `                    ``m.Add(a[i], val + 1);  ` `                ``} ` `                ``else` `                ``{ ` `                    ``m.Add(a[i], 1); ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// index value set to 1  ` `        ``int` `index = 1; ` ` `  `        ``// Return the first value starting  ` `        ``// from 1 which does not exists in map  ` `        ``while` `(``true``)  ` `        ``{ ` `            ``if` `(!m.ContainsKey(index))  ` `            ``{ ` `                ``return` `index; ` `            ``} ` ` `  `            ``index++; ` `        ``} ` `    ``} ` ` `  `    ``// Driver code  ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{ ` `        ``int` `[]a = {1, 1, 1, 0, -1, -2}; ` `        ``int` `size = a.Length; ` ` `  `        ``Console.WriteLine(``"Smallest positive missing number is : "` `                ``+ missingNumber(a, size)); ` `    ``} ` `} ` ` `  `// This code is contributed by Princi Singh `

Output:

```Smallest positive missing number is : 2
```

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

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

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.

Article Tags :
Practice Tags :

5

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.