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


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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to find the smallest
// positive missing number
  
#include <bits/stdc++.h>
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 vaue 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[0]);
  
    cout << "Smallest positive missing number is : "
         << missingNumber(a, size) << endl;
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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<Integer, Integer> 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 vaue 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 vaue 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

chevron_right


Output:

Smallest positive missing number is : 2

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



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.