Find all missing numbers from a given sorted array - GeeksforGeeks

08 Feb, 2022
Given a sorted array arr[] of N integers, The task is to find the multiple missing elements in the array between the ranges [arr[0], arr[N-1]].
Examples:
Input: arr[] = {6, 7, 10, 11, 13}Output: 8 9 12 Explanation: The elements of the array are present in the range of the maximum and minimum array element [6, 13]. Therefore, the total values will be {6, 7, 8, 9, 10, 11, 12, 13}. The elements from the above range which are missing from the array are {8, 9, 12}.  
Input: arr[] = {1, 2, 4, 6}Output: 3 5
Naive Approach: The naive idea is to iterate over the difference between the consecutive pair of elements and the print all the numbers in this range if the difference is non-zero. Below are the steps:
Initialize the variable diff which is equal to arr[0] – 0.Now traverse the array and see if the difference between arr[i] – i and diff is zero or not.If the difference is not equal to zero in the above steps, then the missing element is found.To find the multiple missing elements run a loop inside it and see if the diff is less than arr[i] – i then print the missing element i.e., i + diff.Now increment the diff as the difference is increased now.Repeat from step 2 until all the missing numbers are not found.
Initialize the variable diff which is equal to arr[0] – 0.
Now traverse the array and see if the difference between arr[i] – i and diff is zero or not.
If the difference is not equal to zero in the above steps, then the missing element is found.
To find the multiple missing elements run a loop inside it and see if the diff is less than arr[i] – i then print the missing element i.e., i + diff.
Now increment the diff as the difference is increased now.
Repeat from step 2 until all the missing numbers are not found.
Below is the implementation of the above approach:
C++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; // Function to find the missing elementsvoid printMissingElements(int arr[], int N){     // Initialize diff    int diff = arr[0] - 0;     for (int i = 0; i < N; i++) {         // Check if diff and arr[i]-i        // both are equal or not        if (arr[i] - i != diff) {             // Loop for consecutive            // missing elements            while (diff < arr[i] - i) {                cout << i + diff << " ";                diff++;            }        }    }} // Driver Codeint main(){    // Given array arr[]    int arr[] = { 6, 7, 10, 11, 13 };     int N = sizeof(arr) / sizeof(int);     // Function Call    printMissingElements(arr, N);    return 0;}
// Java program for the above approachimport java.util.*; class GFG{     // Function to find the missing elementsstatic void printMissingElements(int arr[],                                 int N){     // Initialize diff    int diff = arr[0] - 0;     for(int i = 0; i < N; i++)    {         // Check if diff and arr[i]-i        // both are equal or not        if (arr[i] - i != diff)        {             // Loop for consecutive            // missing elements            while (diff < arr[i] - i)            {                System.out.print((i + diff) + " ");                diff++;            }        }    }} // Driver Codepublic static void main (String[] args){         // Given array arr[]    int arr[] = { 6, 7, 10, 11, 13 };         int N = arr.length;         // Function call    printMissingElements(arr, N);}} // This code is contributed by offbeat
# Python3 program for the above approach # Function to find the missing elementsdef printMissingElements(arr, N):     # Initialize diff    diff = arr[0]     for i in range(N):         # Check if diff and arr[i]-i        # both are equal or not        if(arr[i] - i != diff):             # Loop for consecutive            # missing elements            while(diff < arr[i] - i):                print(i + diff, end = " ")                diff += 1 # Driver Code # Given array arr[]arr = [ 6, 7, 10, 11, 13 ] N = len(arr) # Function callprintMissingElements(arr, N) # This code is contributed by Shivam Singh
// C# program for the above approachusing System; class GFG{     // Function to find the missing elementsstatic void printMissingElements(int[] arr,                                 int N){         // Initialize diff    int diff = arr[0] - 0;     for(int i = 0; i < N; i++)    {                 // Check if diff and arr[i]-i        // both are equal or not        if (arr[i] - i != diff)        {                         // Loop for consecutive            // missing elements            while (diff < arr[i] - i)            {                Console.Write(i + diff + " ");                diff++;            }        }    }} // Driver codestatic void Main(){         // Given array arr[]    int[] arr = { 6, 7, 10, 11, 13 };         int N = arr.Length;         // Function call    printMissingElements(arr, N);}} // This code is contributed by divyeshrabadiya07
<script> // Javascript program to gather characters// of a string in minimum cost  // Function to find the missing elementsfunction prletMissingElements(arr, N){      // Initialize diff    let diff = arr[0] - 0;      for(let i = 0; i < N; i++)    {          // Check if diff and arr[i]-i        // both are equal or not        if (arr[i] - i != diff)        {              // Loop for consecutive            // missing elements            while (diff < arr[i] - i)            {                document.write((i + diff) + " ");                diff++;            }        }    }} // Driver Code      // Given array arr[]    let arr = [ 6, 7, 10, 11, 13 ];          let N = arr.length;          // Function call    prletMissingElements(arr, N);      </script>
8 9 12 
Time Complexity: O(N2)Auxiliary Space: O(1)
Efficient Approach: The idea is to use Hashing to optimize the above approach. Create a boolean array(say b[]) of size equal to the maximum element in the array and mark only those positions in the array b[] which are present in the given array. Print all the index in the array b[] that are not marked. Below are the steps:  
Initialize a boolean array b[] with zero of size equals to the maximum element of the array.Iterate over the given array and mark for each element in the given array mark that index as true in the array b[].Now traverse the given array b[] from index arr[0] and print those index whose value is false as they are the element that is missing in the given array.
Initialize a boolean array b[] with zero of size equals to the maximum element of the array.
Iterate over the given array and mark for each element in the given array mark that index as true in the array b[].
Now traverse the given array b[] from index arr[0] and print those index whose value is false as they are the element that is missing in the given array.
Below is the implementation of the above approach: 
C++
Java
Python3
C#
Javascript
// C++ program for the above approach #include <bits/stdc++.h>using namespace std; // Function to find the missing elementsvoid printMissingElements(int arr[], int N){    // Initialize an array with zero    // of size equals to the maximum    // element in the array    int b[arr[N - 1] + 1] = { 0 };     // Make b[i]=1 if i is present    // in the array    for (int i = 0; i < N; i++) {         // If the element is present        // make b[arr[i]]=1        b[arr[i]] = 1;    }     // Print the indices where b[i]=0    for (int i = arr[0]; i <= arr[N - 1]; i++) {         if (b[i] == 0) {            cout << i << " ";        }    }} // Driver Codeint main(){    // Given array arr[]    int arr[] = { 6, 7, 10, 11, 13 };     int N = sizeof(arr) / sizeof(int);     // Function Call    printMissingElements(arr, N);     return 0;}
// Java program for the above approachimport java.util.*; class GFG{     // Function to find the missing elementsstatic void printMissingElements(int arr[],                                int N){         // Initialize an array with zero    // of size equals to the maximum    // element in the array    int[] b = new int[arr[N - 1] + 1];     // Make b[i]=1 if i is present    // in the array    for(int i = 0; i < N; i++)    {                 // If the element is present        // make b[arr[i]]=1        b[arr[i]] = 1;    }     // Print the indices where b[i]=0    for(int i = arr[0]; i <= arr[N - 1]; i++)    {        if (b[i] == 0)        {            System.out.print(i + " ");        }    }} // Driver Codepublic static void main (String[] args){         // Given array arr[]    int arr[] = { 6, 7, 10, 11, 13 };         int N = arr.length;         // Function call    printMissingElements(arr, N);}} // This code is contributed by offbeat
# Python3 program to implement# the above approach # Function to find the missing elementsdef printMissingElements(arr, N):     # Initialize an array with zero    # of size equals to the maximum    # element in the array    b = [0] * (arr[N - 1] + 1)     # Make b[i]=1 if i is present    # in the array    for i in range(N):         # If the element is present        # make b[arr[i]]=1        b[arr[i]] = 1     # Print the indices where b[i]=0    for i in range(arr[0], arr[N - 1] + 1):        if(b[i] == 0):            print(i, end = " ") # Driver Code # Given array arr[]arr = [ 6, 7, 10, 11, 13 ] N = len(arr) # Function callprintMissingElements(arr, N) # This code is contributed by Shivam Singh
// C# program for// the above approachusing System;class GFG{     // Function to find the missing elementsstatic void printMissingElements(int []arr,                                 int N){      // Initialize an array with zero  // of size equals to the maximum  // element in the array  int[] b = new int[arr[N - 1] + 1];   // Make b[i]=1 if i is present  // in the array  for(int i = 0; i < N; i++)  {    // If the element is present    // make b[arr[i]]=1    b[arr[i]] = 1;  }   // Print the indices where b[i]=0  for(int i = arr[0]; i <= arr[N - 1];          i++)  {    if (b[i] == 0)    {      Console.Write(i + " ");    }  }} // Driver Codepublic static void Main(String[] args){  // Given array []arr  int []arr = {6, 7, 10, 11, 13};   int N = arr.Length;   // Function call  printMissingElements(arr, N);}} // This code is contributed by Princi Singh
<script> // JavaScript program for the above approach // Function to find the missing elementsfunction printMissingElements(arr, N){    // Initialize an array with zero    // of size equals to the maximum    // element in the array    let b  = new Uint8Array(arr[N - 1] + 1);     // Make b[i]=1 if i is present    // in the array    for (let i = 0; i < N; i++) {         // If the element is present        // make b[arr[i]]=1        b[arr[i]] = 1;    }     // Print the indices where b[i]=0    for (let i = arr[0]; i <= arr[N - 1]; i++) {         if (b[i] == 0) {            document.write( i + " ");        }    }} // Driver Code     // Given array arr[]    let arr = [ 6, 7, 10, 11, 13 ];     let N = arr.length;     // Function Call    printMissingElements(arr, N);      //This code is contributed by Mayank Tyagi</script>
8 9 12 
Time Complexity: O(M), where M is the maximum element of the array. Auxiliary Space: O(M)
Most Efficient  And Simple Approach: 
In below approach simple we create a variable (cnt) this variable keeps the track of element present in array
1. We need to traverse the arr[0] to arr[N] to find missing number between it.
2. In for loop if arr[cnt] match to current element then we do not print that element and skip that element because it is present in array 
once we found element then we increment the cnt++ for pointing next element in array 
3. In else part we just print the element which does not match or present in array
C++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; // Function to find the missing elementsvoid printMissingElements(int arr[], int N){    int cnt = 0;    for (int i = arr[0]; i <= arr[N - 1]; i++) {        // Check if number is equal to the first element in        // given array if array element match skip it increment for next element        if (arr[cnt] == i) {            // Increment the count to check next element            cnt++;        }        else {            // Print missing number            cout << i << " ";        }    }}// Driver Codeint main(){    // Given array arr[]    int arr[] = { 6, 7, 10, 11, 13 };    int N = sizeof(arr) / sizeof(arr[0]);    // Function Call    printMissingElements(arr, N);     return 0;}//This code is contributed by Kuldeep Kushwaha
//Java program for the above approachimport java.io.*;class GFG {   // Function to find the missing elements  public static void printMissingElements(int arr[], int N)  {    int cnt = 0;    for (int i = arr[0]; i <= arr[N - 1]; i++)    {       // Check if number is equal to the first element in      // given array if array element match skip it increment for next element      if (arr[cnt] == i)      {         // Increment the count to check next element        cnt++;      }      else      {         // Print missing number        System.out.print(i + " ");      }    }  }   // Driver Code  public static void main (String[] args)  {     // Given array arr[]    int arr[] = { 6, 7, 10, 11, 13 };    int N = arr.length;     // Function Call    printMissingElements(arr, N);  }} // This code is contributed by Shubham Singh
# Python program for the above approach # Function to find the missing elementsdef printMissingElements(arr, N):    cnt = 0    for i in range(arr[0], arr[N - 1]+1):                 # Check if number is equal to the first element in        # given array if array element match skip it increment for next element        if (arr[cnt] == i):                         # Increment the count to check next element            cnt += 1                     else:                         # Print missing number            print(i , end = " ")             # Driver Code# Given array arr[]arr = [ 6, 7, 10, 11, 13 ]N = len(arr) # Function CallprintMissingElements(arr, N) # This code is contributed by Shubham Singh
//C# program for the above approachusing System;using System.Linq; public class GFG{   // Function to find the missing elements  public static void printMissingElements(int[] arr, int N)  {    int cnt = 0;    for (int i = arr[0]; i <= arr[N - 1]; i++)    {       // Check if number is equal to the first element in      // given array if array element match skip it increment for next element      if (arr[cnt] == i)      {         // Increment the count to check next element        cnt++;      }      else      {         // Print missing number        Console.Write(i + " ");      }    }  }   // Driver Code  static public void Main ()  {     // Given array arr[]    int[] arr = { 6, 7, 10, 11, 13 };    int N = arr.Length;     // Function Call    printMissingElements(arr, N);  }} // This code is contributed by Shubham Singh
<script>// Javascript program for the above approach // Function to find the missing elementsfunction printMissingElements(arr, N){    var cnt = 0;    for (var i = arr[0]; i <= arr[N - 1]; i++) {                 // Check if number is equal to the first element in        // given array if array element match skip it increment for next element        if (arr[cnt] == i)        {                     // Increment the count to check next element            cnt++;        }        else        {                     // Print missing number            document.write(i + " ");        }    }} // Driver Code // Given array arr[]var arr = [ 6, 7, 10, 11, 13 ];var N = arr.length; // Function CallprintMissingElements(arr, N); // This code is contributed by Shubham Singh</script>
8 9 12 
Time Complexity: O(N), where N is the maximum element of the array. 
Auxiliary Space: O(1) Because of this method the overflow of hash or extra space will be saved.
SHIVAMSINGH67
offbeat
divyeshrabadiya07
princi singh
chinmoy1997pal
mayanktyagi1709
kushwahakuldeep321
SHUBHAMSINGH10
frequency-counting
HashTable
Arrays
Greedy
Hash
Mathematical
Arrays
Hash
Greedy
Mathematical
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Chocolate Distribution Problem
Count pairs with given sum
Window Sliding Technique
Reversal algorithm for array rotation
Next Greater Element
Dijkstra's shortest path algorithm | Greedy Algo-7
Prim’s Minimum Spanning Tree (MST) | Greedy Algo-5
Kruskal’s Minimum Spanning Tree Algorithm | Greedy Algo-2
Write a program to print all permutations of a given string
Huffman Coding | Greedy Algo-3