# Find missing element in a sorted array of consecutive numbers in C++

C++Server Side ProgrammingProgramming

## Concept

With respect of a given array array[] of n distinct integers, elements are placed sequentially in ascending order with one missing element. Our task is to determine the missing element.

## Input

array[] = {1, 2, 3, 4, 5, 6, 7, 9}

## Output

8

## Input

array[] = {-4, -2, -1, 0, 1, 2}

## Output

-3

## Input

array[] = {1, 2, 3, 4}

## Output

-1

No element is missing.

## Method

### Principles

• Look for inconsistency: According to this principle, the difference between any element and its index must be array for every element.

Example,

A[] = {1, 2, 3, 4, 5} -> Consistent

B[] = {201, 202, 203, 204} -> Consistent

C[] = {1, 2, 3, 5, 6} -> Inconsistent as C – 3 != C i.e. 5 – 3 != 1

• Determining inconsistency helps to scan only half of the array each time in O(logN).

### Algorithm

• Determine middle element and verify if it’s consistent.

• If middle element is consistent, then verify if the difference between middle element and its next element is higher than 1 i.e. verify if array[mid + 1] – array[mid] > 1

• If yes, then array[mid] + 1 is the missing element.

• Else, we have to scan the right half array from the middle element and jump to step-1.

• If middle element is inconsistent, then verify if the difference between middle element and its previous element is higher than 1 i.e. verify if array[mid] – array[mid – 1] > 1

• If yes, then array[mid] – 1 is the missing element.

• Else, we have to scan the left half array from the middle element and jump to step-1.

## Example

Live Demo

// CPP implementation of the approach
#include<bits/stdc++.h>
using namespace std;
// Shows function to return the missing element
int findMissing(int array[], int n1){
int low = 0, high = n1 - 1;
int mid1;
while (high > low){
mid1 = low + (high - low) / 2;
// Verify if middle element is consistent
if (array[mid1] - mid1 == array){
// Here, no inconsistency till middle elements
// When missing element is just after
// the middle element
if (array[mid1 + 1] - array[mid1] > 1)
return array[mid1] + 1;
else{
// Go right
low = mid1 + 1;
}
}
else{
// Here inconsistency found
// When missing element is just before
// the middle element
if (array[mid1] - array[mid1 - 1] > 1)
return array[mid1] - 1;
else{
// Go left
high = mid1 - 1;
}
}
}
// Here, no missing element found
return -1;
}
// Driver code
int main(){
int array[] = { -9, -8, -6, -5, -4, -3, -2, -1, 0 };
int n1 = sizeof(array)/sizeof(array);
cout <<"The Missing Element:" <<(findMissing(array, n1));
}

## Output

The Missing Element:-7