Find the smallest missing number

Last Updated : 03 Jul, 2023

Given a sorted array of n distinct integers where each integer is in the range from 0 to m-1 and m > n. Find the smallest number that is missing from the array.

Examples:

Input: {0, 1, 2, 6, 9}, n = 5, m = 10   Output: 3    Input: {4, 5, 10, 11}, n = 4, m = 12   Output: 0    Input: {0, 1, 2, 3}, n = 4, m = 5   Output: 4    Input: {0, 1, 2, 3, 4, 5, 6, 7, 10}, n = 9, m = 11   Output: 8

Thanks to Ravichandra for suggesting following two methods.

Method 1 (Use Binary Search)
For i = 0 to m-1, do binary search for i in the array. If i is not present in the array then return i.
Time Complexity: O(m log n)

Method 2 (Linear Search)
If arr[0] is not 0, return 0. Otherwise traverse the input array starting from index 0, and for each pair of elements a[i] and a[i+1], find the difference between them. if the difference is greater than 1 then a[i]+1 is the missing number.
Time Complexity: O(n)

Another approach using linear search involves no need of finding the difference between the elements a[i] and a[i+1]. Starting from arr[0] to arr[n-1] check until arr[i] != i. If the condition (arr[i] != i) is satisfied then 'i' is the smallest missing number. If the condition is not satisfied, then it means there is no missing number in the given arr[], then return the element arr[n-1]+1 which is same as 'n'.

Time Complexity: O(n)

Method 3 (Use Modified Binary Search)
Thanks to yasein and Jams for suggesting this method.
In the standard Binary Search process, the element to be searched is compared with the middle element and on the basis of comparison result, we decide whether to search is over or to go to left half or right half.
In this method, we modify the standard Binary Search algorithm to compare the middle element with its index and make decision on the basis of this comparison.

If the first element is not same as its index then return first index
Else get the middle index say mid
- If arr[mid] greater than mid then the required element lies in left half.
- Else the required element lies in right half.

C++

// C++ program to find the smallest elements // missing in a sorted array. #include<bits/stdc++.h> using namespace std;  int findFirstMissing(int array[],                      int start, int end) {     if (start > end)         return end + 1;      if (start != array[start])         return start;      int mid = (start + end) / 2;      // Left half has all elements      // from 0 to mid     if (array[mid] == mid)         return findFirstMissing(array,                              mid+1, end);      return findFirstMissing(array, start, mid); }  // Driver code int main() {     int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 10};     int n = sizeof(arr)/sizeof(arr[0]);     cout << "Smallest missing element is " <<         findFirstMissing(arr, 0, n-1) << endl; }  // This code is contributed by // Shivi_Aggarwal

// C program to find the smallest elements missing // in a sorted array. #include<stdio.h>  int findFirstMissing(int array[], int start, int end) {     if (start  > end)         return end + 1;      if (start != array[start])         return start;      int mid = (start + end) / 2;      // Left half has all elements from 0 to mid     if (array[mid] == mid)         return findFirstMissing(array, mid+1, end);      return findFirstMissing(array, start, mid); }  // driver program to test above function int main() {     int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 10};     int n = sizeof(arr)/sizeof(arr[0]);     printf("Smallest missing element is %d",            findFirstMissing(arr, 0, n-1));     return 0; }

Java

import java.io.*;  class SmallestMissing  {     int findFirstMissing(int array[], int start, int end)      {         if (start > end)             return end + 1;          if (start != array[start])             return start;          int mid = (start + end) / 2;          // Left half has all elements from 0 to mid         if (array[mid] == mid)             return findFirstMissing(array, mid+1, end);          return findFirstMissing(array, start, mid);     }      // Driver program to test the above function     public static void main(String[] args)      {         SmallestMissing small = new SmallestMissing();         int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 10};         int n = arr.length;         System.out.println("First Missing element is : "                 + small.findFirstMissing(arr, 0, n - 1));     } }

Python3

# Python3 program to find the smallest # elements missing in a sorted array.  def findFirstMissing(array, start, end):      if (start > end):         return end + 1      if (start != array[start]):         return start;      mid = int((start + end) / 2)      # Left half has all elements     # from 0 to mid     if (array[mid] == mid):         return findFirstMissing(array,                           mid+1, end)      return findFirstMissing(array,                            start, mid)   # driver program to test above function arr = [0, 1, 2, 3, 4, 5, 6, 7, 10] n = len(arr) print("Smallest missing element is",       findFirstMissing(arr, 0, n-1))  # This code is contributed by Smitha Dinesh Semwal

// C# program to find the smallest // elements missing in a sorted array. using System;  class GFG {     static int findFirstMissing(int []array,                             int start, int end)      {         if (start > end)             return end + 1;          if (start != array[start])             return start;          int mid = (start + end) / 2;          // Left half has all elements from 0 to mid         if (array[mid] == mid)             return findFirstMissing(array, mid+1, end);          return findFirstMissing(array, start, mid);     }      // Driver program to test the above function     public static void Main()      {         int []arr = {0, 1, 2, 3, 4, 5, 6, 7, 10};         int n = arr.Length;                  Console.Write("smallest Missing element is : "                     + findFirstMissing(arr, 0, n - 1));     } }  // This code is contributed by Sam007

PHP

<?php // PHP program to find the // smallest elements missing // in a sorted array.  // function that returns  // smallest elements missing // in a sorted array. function findFirstMissing($array, $start, $end) {     if ($start > $end)         return $end + 1;      if ($start != $array[$start])         return $start;      $mid = ($start + $end) / 2;      // Left half has all      // elements from 0 to mid     if ($array[$mid] == $mid)         return findFirstMissing($array,                                  $mid + 1,                                  $end);      return findFirstMissing($array,                              $start,                              $mid); }      // Driver Code     $arr = array (0, 1, 2, 3, 4, 5, 6, 7, 10);     $n = count($arr);     echo "Smallest missing element is " ,           findFirstMissing($arr, 2, $n - 1);          // This code Contributed by Ajit. ?>

JavaScript

<script>      // Javascript program to find the smallest     // elements missing in a sorted array.          function findFirstMissing(array, start, end)      {         if (start > end)             return end + 1;            if (start != array[start])             return start;            let mid = parseInt((start + end) / 2, 10);            // Left half has all elements from 0 to mid         if (array[mid] == mid)             return findFirstMissing(array, mid+1, end);            return findFirstMissing(array, start, mid);     }          let arr = [0, 1, 2, 3, 4, 5, 6, 7, 10];     let n = arr.length;      document.write("smallest Missing element is " +      findFirstMissing(arr, 0, n - 1));      </script>

Output

Smallest missing element is 8

Note: This method doesn't work if there are duplicate elements in the array.
Time Complexity: O(Log n)
Auxiliary Space : O(Log n)

Another Method: The idea is to use Recursive Binary Search to find the smallest missing number. Below is the illustration with the help of steps:

If the first element of the array is not 0, then the smallest missing number is 0.
If the last elements of the array is N-1, then the smallest missing number is N.
Otherwise, find the middle element from the first and last index and check if the middle element is equal to the desired element. i.e. first + middle_index.
- If the middle element is the desired element, then the smallest missing element is in the right search space of the middle.
- Otherwise, the smallest missing number is in the left search space of the middle.

Below is the implementation of the above approach:

C++

//C++ program for the above approach #include <bits/stdc++.h>  using namespace std;  // Program to find missing element int findFirstMissing(vector<int> arr , int start ,                         int  end,int first) {    if (start < end)   {     int mid = (start + end) / 2;      /** Index matches with value       at that index, means missing       element cannot be upto that po*/     if (arr[mid] != mid+first)       return findFirstMissing(arr, start,                                  mid , first);     else       return findFirstMissing(arr, mid + 1,                                  end , first);   }   return start + first;  }  // Program to find Smallest // Missing in Sorted Array int findSmallestMissinginSortedArray(vector<int> arr) {      // Check if 0 is missing   // in the array   if(arr[0] != 0)     return 0;    // Check is all numbers 0 to n - 1   // are present in array   if(arr[arr.size() - 1] == arr.size() - 1)     return arr.size();    int first = arr[0];    return findFirstMissing(arr, 0, arr.size() - 1, first); }   // Driver program to test the above function int main() {     vector<int> arr = {0, 1, 2, 3, 4, 5, 7};     int n = arr.size();      // Function Call     cout<<"First Missing element is : "<<findSmallestMissinginSortedArray(arr); }  // This code is contributed by mohit kumar 29.

Java

// Java Program for above approach import java.io.*;  class GFG  {        // Program to find Smallest      // Missing in Sorted Array     int findSmallestMissinginSortedArray(                               int[] arr)      {        // Check if 0 is missing        // in the array       if(arr[0] != 0)         return 0;              // Check is all numbers 0 to n - 1        // are present in array       if(arr[arr.length-1] == arr.length - 1)         return arr.length;              int first = arr[0];        return findFirstMissing(arr,0,                        arr.length-1,first);     }          // Program to find missing element      int findFirstMissing(int[] arr , int start ,                                int end, int first)      {              if (start < end)        {         int mid = (start+end)/2;          /** Index matches with value            at that index, means missing           element cannot be upto that point */         if (arr[mid] != mid+first)           return findFirstMissing(arr, start,                                       mid , first);         else           return findFirstMissing(arr, mid+1,                                       end , first);       }       return start+first;      }        // Driver program to test the above function     public static void main(String[] args)      {         GFG small = new GFG();         int arr[] = {0, 1, 2, 3, 4, 5, 7};         int n = arr.length;                  // Function Call         System.out.println("First Missing element is : "             + small.findSmallestMissinginSortedArray(arr));     } }

Python3

# Python3 program for above approach   # Function to find Smallest   # Missing in Sorted Array def findSmallestMissinginSortedArray(arr):          # Check if 0 is missing       # in the array      if (arr[0] != 0):         return 0          # Check is all numbers 0 to n - 1       # are present in array      if (arr[-1] == len(arr) - 1):         return len(arr)          first = arr[0]          return findFirstMissing(arr, 0,              len(arr) - 1, first)  # Function to find missing element   def findFirstMissing(arr, start, end, first):          if (start < end):         mid = int((start + end) / 2)                  # Index matches with value           # at that index, means missing          # element cannot be upto that point          if (arr[mid] != mid + first):             return findFirstMissing(arr, start,                                     mid, first)         else:             return findFirstMissing(arr, mid + 1,                                       end, first)          return start + first  # Driver code arr = [ 0, 1, 2, 3, 4, 5, 7 ] n = len(arr)  # Function Call  print("First Missing element is :",       findSmallestMissinginSortedArray(arr))  # This code is contributed by rag2127

// C# program for above approach  using System;  class GFG{      // Program to find Smallest   // Missing in Sorted Array  int findSmallestMissinginSortedArray(int[] arr)   {            // Check if 0 is missing       // in the array      if (arr[0] != 0)          return 0;           // Check is all numbers 0 to n - 1       // are present in array      if (arr[arr.Length - 1] == arr.Length - 1)          return arr.Length;           int first = arr[0];           return findFirstMissing(arr, 0,             arr.Length - 1,first);  }       // Program to find missing element   int findFirstMissing(int[] arr , int start ,                        int end, int first)   {           if (start < end)       {          int mid = (start + end) / 2;                   /*Index matches with value           at that index, means missing          element cannot be upto that point */         if (arr[mid] != mid+first)              return findFirstMissing(arr, start,                                       mid, first);          else             return findFirstMissing(arr, mid + 1,                                       end, first);      }      return start + first;  }  // Driver code static public void Main () {     GFG small = new GFG();      int[] arr = {0, 1, 2, 3, 4, 5, 7};      int n = arr.Length;           // Function Call      Console.WriteLine("First Missing element is : " +      small.findSmallestMissinginSortedArray(arr));  } }  // This code is contributed by avanitrachhadiya2155

JavaScript

<script>  // Javascript program for the above approach  // Program to find missing element function findFirstMissing(arr, start, end, first) {     if (start < end)     {         let mid = (start + end) / 2;              /** Index matches with value         at that index, means missing         element cannot be upto that po*/         if (arr[mid] != mid + first)             return findFirstMissing(arr, start,                                     mid, first);         else             return findFirstMissing(arr, mid + 1,                                     end, first);     }     return start + first; }  // Program to find Smallest // Missing in Sorted Array function findSmallestMissinginSortedArray(arr) {          // Check if 0 is missing     // in the array     if (arr[0] != 0)         return 0;          // Check is all numbers 0 to n - 1     // are present in array     if (arr[arr.length - 1] == arr.length - 1)         return arr.length;          let first = arr[0];          return findFirstMissing(         arr, 0, arr.length - 1, first); }  // Driver code let arr = [ 0, 1, 2, 3, 4, 5, 7 ]; let n = arr.length;  // Function Call document.write("First Missing element is : " +       findSmallestMissinginSortedArray(arr));  // This code is contributed by Mayank Tyagi  </script>

Output

First Missing element is : 6

Time Complexity: O(Log n)
Auxiliary Space : O(Log n)

Method-4(Using Hash Vector)

Make a vector of size m and initialize that with 0, so that every element of the array can be treated as an index of the vector.

Now traverse the array and mark the value as 1 in vector at a position equal to the element of the array. Now traverse the vector and find the first index where we get a value of 0, then that index is the smallest missing number.

Code-

C++

// C++ program to find the smallest element // missing in a sorted array. #include<bits/stdc++.h> using namespace std;  int findFirstMissing(int arr[],int n ,int m) {     vector<int> vec(m,0);      for(int i=0;i<n;i++){       vec[arr[i]]=1;   }      for(int i=0;i<m;i++){       if(vec[i]==0){return i;}   } }  // Driver code int main() {     int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 10};     int n = sizeof(arr)/sizeof(arr[0]);     int m=11;     cout << "Smallest missing element is " <<findFirstMissing(arr, n, m) << endl; }

Java

// Java program to find the smallest element // missing in a sorted array.  import java.util.*;  class Main {          static int findFirstMissing(int arr[], int n, int m) {         int vec[] = new int[m];                  for (int i = 0; i < n; i++) {             vec[arr[i]] = 1;         }                  for (int i = 0; i < m; i++) {             if (vec[i] == 0) {                 return i;             }         }         return m;     } // Driver code            public static void main(String[] args) {         int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 10};         int n = arr.length;         int m = 11;         System.out.println("Smallest missing element is " + findFirstMissing(arr, n, m));     } }

Python3

# Python program to find the smallest element missing in a sorted array.  def findFirstMissing(arr, n, m):     vec = [0] * m      for i in range(n):         vec[arr[i]] = 1              for i in range(m):         if vec[i] == 0:             return i                  return m  # Driver code arr = [0, 1, 2, 3, 4, 5, 6, 7, 10] n = len(arr) m = 11 print("Smallest missing element is", findFirstMissing(arr, n, m))

using System;  public class Program {     // function to find the smallest missing element in a sorted array     public static int FindFirstMissing(int[] arr, int n, int m)     {         // create an auxiliary array of size m with all elements set to 0         int[] vec = new int[m];          // iterate over the input array and set the corresponding element in vec to 1 if it is present in arr         for (int i = 0; i < n; i++)         {             vec[arr[i]] = 1;         }          // iterate over the range 0 to m and return the first index where the corresponding element in vec is 0         for (int i = 0; i < m; i++)         {             if (vec[i] == 0)             {                 return i;             }         }          // if all elements in the range are present, return m (the upper bound of the range)         return m;     }      public static void Main()     {         // initialize an example array, compute its length, and set the upper bound of the range of elements         int[] arr = { 0, 1, 2, 3, 4, 5, 6, 7, 10 };         int n = arr.Length;         int m = 11;          // call the FindFirstMissing function and output the result to the console         Console.WriteLine("Smallest missing element is " + FindFirstMissing(arr, n, m));     } }

JavaScript

// JS program to find the smallest element // missing in a sorted array. function findFirstMissing(arr, n, m) {   let vec = new Array(m).fill(0);      for (let i = 0; i < n; i++) {     vec[arr[i]] = 1;   }    for (let i = 0; i < m; i++) {     if (vec[i] === 0) {       return i;     }   } }  let arr = [0, 1, 2, 3, 4, 5, 6, 7, 10]; let n = arr.length; let m = 11; console.log("Smallest missing element is " + findFirstMissing(arr, n, m));

Output-

Smallest missing element is 8

Time Complexity: O(m+n), where n is the size of the array and m is the range of elements in the array
Auxiliary Space : O(m), where n is the size of the array

Please write comments if you find the above codes/algorithms incorrect, or find other ways to solve the same problem.

Difference Array | Range update query in O(1)

kartik

Improve

Article Tags :

Practice Tags :

Find the smallest missing number

Similar Reads

Basic operations in Array

Easy problems on Array

Intermediate problems on Array

Hard problems on Array