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++
#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;
if (array[mid] == mid)
return findFirstMissing(array,
mid+1, end);
return findFirstMissing(array, start, mid);
}
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;
}
|
C
#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;
if (array[mid] == mid)
return findFirstMissing(array, mid+1, end);
return findFirstMissing(array, start, mid);
}
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 ;
if (array[mid] == mid)
return findFirstMissing(array, mid+ 1 , end);
return findFirstMissing(array, start, mid);
}
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
def findFirstMissing(array, start, end):
if (start > end):
return end + 1
if (start ! = array[start]):
return start;
mid = int ((start + end) / 2 )
if (array[mid] = = mid):
return findFirstMissing(array,
mid + 1 , end)
return findFirstMissing(array,
start, mid)
arr = [ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 10 ]
n = len (arr)
print ( "Smallest missing element is" ,
findFirstMissing(arr, 0 , n - 1 ))
|
C#
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;
if (array[mid] == mid)
return findFirstMissing(array, mid+1, end);
return findFirstMissing(array, start, mid);
}
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));
}
}
|
PHP
<?php
function findFirstMissing( $array , $start , $end )
{
if ( $start > $end )
return $end + 1;
if ( $start != $array [ $start ])
return $start ;
$mid = ( $start + $end ) / 2;
if ( $array [ $mid ] == $mid )
return findFirstMissing( $array ,
$mid + 1,
$end );
return findFirstMissing( $array ,
$start ,
$mid );
}
$arr = array (0, 1, 2, 3, 4, 5, 6, 7, 10);
$n = count ( $arr );
echo "Smallest missing element is " ,
findFirstMissing( $arr , 2, $n - 1);
?>
|
Javascript
<script>
function findFirstMissing(array, start, end)
{
if (start > end)
return end + 1;
if (start != array[start])
return start;
let mid = parseInt((start + end) / 2, 10);
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++
#include <bits/stdc++.h>
using namespace std;
int findFirstMissing(vector< int > arr , int start ,
int end, int first)
{
if (start < end)
{
int mid = (start + end) / 2;
if (arr[mid] != mid+first)
return findFirstMissing(arr, start,
mid , first);
else
return findFirstMissing(arr, mid + 1,
end , first);
}
return start + first;
}
int findSmallestMissinginSortedArray(vector< int > arr)
{
if (arr[0] != 0)
return 0;
if (arr[arr.size() - 1] == arr.size() - 1)
return arr.size();
int first = arr[0];
return findFirstMissing(arr, 0, arr.size() - 1, first);
}
int main()
{
vector< int > arr = {0, 1, 2, 3, 4, 5, 7};
int n = arr.size();
cout<< "First Missing element is : " <<findSmallestMissinginSortedArray(arr);
}
|
Java
import java.io.*;
class GFG
{
int findSmallestMissinginSortedArray(
int [] arr)
{
if (arr[ 0 ] != 0 )
return 0 ;
if (arr[arr.length- 1 ] == arr.length - 1 )
return arr.length;
int first = arr[ 0 ];
return findFirstMissing(arr, 0 ,
arr.length- 1 ,first);
}
int findFirstMissing( int [] arr , int start ,
int end, int first)
{
if (start < end)
{
int mid = (start+end)/ 2 ;
if (arr[mid] != mid+first)
return findFirstMissing(arr, start,
mid , first);
else
return findFirstMissing(arr, mid+ 1 ,
end , first);
}
return start+first;
}
public static void main(String[] args)
{
GFG small = new GFG();
int arr[] = { 0 , 1 , 2 , 3 , 4 , 5 , 7 };
int n = arr.length;
System.out.println( "First Missing element is : "
+ small.findSmallestMissinginSortedArray(arr));
}
}
|
Python3
def findSmallestMissinginSortedArray(arr):
if (arr[ 0 ] ! = 0 ):
return 0
if (arr[ - 1 ] = = len (arr) - 1 ):
return len (arr)
first = arr[ 0 ]
return findFirstMissing(arr, 0 ,
len (arr) - 1 , first)
def findFirstMissing(arr, start, end, first):
if (start < end):
mid = int ((start + end) / 2 )
if (arr[mid] ! = mid + first):
return findFirstMissing(arr, start,
mid, first)
else :
return findFirstMissing(arr, mid + 1 ,
end, first)
return start + first
arr = [ 0 , 1 , 2 , 3 , 4 , 5 , 7 ]
n = len (arr)
print ( "First Missing element is :" ,
findSmallestMissinginSortedArray(arr))
|
C#
using System;
class GFG{
int findSmallestMissinginSortedArray( int [] arr)
{
if (arr[0] != 0)
return 0;
if (arr[arr.Length - 1] == arr.Length - 1)
return arr.Length;
int first = arr[0];
return findFirstMissing(arr, 0,
arr.Length - 1,first);
}
int findFirstMissing( int [] arr , int start ,
int end, int first)
{
if (start < end)
{
int mid = (start + end) / 2;
if (arr[mid] != mid+first)
return findFirstMissing(arr, start,
mid, first);
else
return findFirstMissing(arr, mid + 1,
end, first);
}
return start + first;
}
static public void Main ()
{
GFG small = new GFG();
int [] arr = {0, 1, 2, 3, 4, 5, 7};
int n = arr.Length;
Console.WriteLine( "First Missing element is : " +
small.findSmallestMissinginSortedArray(arr));
}
}
|
Javascript
<script>
function findFirstMissing(arr, start, end, first)
{
if (start < end)
{
let mid = (start + end) / 2;
if (arr[mid] != mid + first)
return findFirstMissing(arr, start,
mid, first);
else
return findFirstMissing(arr, mid + 1,
end, first);
}
return start + first;
}
function findSmallestMissinginSortedArray(arr)
{
if (arr[0] != 0)
return 0;
if (arr[arr.length - 1] == arr.length - 1)
return arr.length;
let first = arr[0];
return findFirstMissing(
arr, 0, arr.length - 1, first);
}
let arr = [ 0, 1, 2, 3, 4, 5, 7 ];
let n = arr.length;
document.write( "First Missing element is : " +
findSmallestMissinginSortedArray(arr));
</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++
#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;}
}
}
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
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;
}
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
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
arr = [ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 10 ]
n = len (arr)
m = 11
print ( "Smallest missing element is" , findFirstMissing(arr, n, m))
|
C#
using System;
public class Program
{
public 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;
}
public static void Main()
{
int [] arr = { 0, 1, 2, 3, 4, 5, 6, 7, 10 };
int n = arr.Length;
int m = 11;
Console.WriteLine( "Smallest missing element is " + FindFirstMissing(arr, n, m));
}
}
|
Javascript
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.
Share your thoughts in the comments
Please Login to comment...