# JavaScript Program for Find the smallest missing number

We are given a sorted array of distinct non-negative integers, here we have to find the smallest missing number. Hence in this tutorial, we will explore different methods to solve this problem and discuss their time complexities with various examples.

## Understanding the Problem

The problem statement is quite simple. Given a sorted array of distinct non-negative integers, we need to find the smallest missing number in it. Let's take an example to understand the problem.

### Example

Let’s say that we have an array [1, 2, 4, 5, 6]. Here, We can see that there is a space between the numbers 2 and 4 in this array. This difference shows that there is a number which is gone missing. Now we have to find the smallest number that can fit in that place.

To determine if there is a missing number, we must first see if the number 3 is included in the array. If the number 3 is absent from the array, we can say that it is a missing number, because the number 3 is not included in the array.

Now let’s see some methods to solve this problem.

## Method 1: The Naive Approach

One of the easiest methods to solve this problem is to loop over the array and ensure that each item is in the right location. If the element is not in its proper place, we will discover the smallest missing number.

### Example

Here is the code for the above explanation −

<!DOCTYPE html>
<html>
<body>
<h2>Find Smallest Missing Number</h2>
<p>Array: [0, 1, 2, 3, 5, 6]</p>
<p>Result: <span id="result"></span></p>
<script>
function findSmallestMissingNumber(arr) {
let n = arr.length;
for (let i = 0; i < n; i++) {
if (arr[i] !== i) {
return i;
}
}
return n;
}
const arr = [0, 1, 2, 3, 5, 6];
const result = findSmallestMissingNumber(arr);
document.getElementById("result").innerHTML = result;
</script>
</body>
</html>


Since we are iterating through the entire array, the time complexity of this method is O(n).

However, this solution is inefficient as it doesn't take advantage of the fact that "there is a sorted array provided to us".

## Method 2: Binary Search Approach

Here, we will use the binary search approach to solve this problem more efficiently. In this approach, we do a binary search for the first element that is not present in the array. The code for this approach would be −

### Example

<!DOCTYPE html>
<html>
<body>
<div id="result"></div>
<script>
function findSmallestMissingNumber(arr) {
let n = arr.length;
let low = 0;
let high = n - 1;
let mid = 0;
while (high - low > 1) {
mid = Math.floor((low + high) / 2);
if (arr[mid] - mid !== arr[low] - low) {
high = mid;
} else if (arr[mid] - mid !== arr[high] - high) {
low = mid;
}
}
return arr[low] + 1;
}
const arr = [0, 1, 2, 3, 4, 5, 6, 8];
const result = findSmallestMissingNumber(arr);
document.getElementById("result").innerHTML = "Array: " + JSON.stringify(arr) ;
document.getElementById("result").innerHTML += "<br>The smallest missing number is: " + result;
</script>
</body>
</html>


The time complexity of the above approach is O(log n) as we are doing a binary search.

This approach is more efficient than our naive approach as it takes advantage of the fact that the array is sorted.

## Method 3: Linear Search Approach

The third method we will discuss is the linear search approach. This method relies on the fact that the array is sorted, which will allow us to apply a linear search to identify the missing number.

The linear search method works by iterating through the array and comparing each member to its index. If an element's index is not equal to its value, the missing element is elsewhere in the array before it. We return the missing element's index.

### Example

The code for the linear search method is as follows −

<!DOCTYPE html>
<html>
<body>
<h2>Find Smallest Missing Number</h2>
<p>Array: [1, 2, 3, 5]</p>
<p>Result: <span id="result"></span></p>
<script>
function findSmallestMissingNumber(arr) {
for (let i = 0; i < arr.length; i++) {
if (arr[i] !== i+1) {
return i+1;
}
}
return arr.length+1;
}
const arr = [1, 2, 3, 5];
const result = findSmallestMissingNumber(arr);
document.getElementById("result").innerHTML = result;
</script>
</body>
</html>


The time complexity of this approach is O(n), as we are iterating over the entire array.

This approach is less efficient than the binary search approach but can be useful for small arrays.

## Method 4: Modified Binary Search

The fourth method we will discuss is the modified binary search approach. This method is quite similar to the binary search method, except that instead of comparing the middle element to the missing integer, we compare it to its index.

The basic idea behind the modified binary search approach is to divide the array in half at every step and compare the middle element with its index. If the middle element is greater than its index, the missing member must be in the array's left half. If the middle element is equal to or less than its index, the missing element must be in the array's right half.

### Example

Here is the code implementation of the modified binary search method −

<!DOCTYPE html>
<html>
<body>
<h2>Find Smallest Missing Number</h2>
<p>Predefined array:</p>
<pre id="inputArray"></pre>
<button onclick="findMissingNumber()">Find Missing Number</button>
<p id="result"></p>
<script>

// Define the input array
const inputArray = [0, 1, 2, 3, 4, 6, 7, 8];

// Display the input array in the pre tag
document.getElementById("inputArray").innerHTML = JSON.stringify(inputArray);
function findMissingNumber() {

// Call the findSmallestMissingNumber function to get the result
const result = findSmallestMissingNumber(inputArray);

// Display the result using the innerHTML method
document.getElementById("result").innerHTML = The smallest missing number is: \${result};
}

// Copy the findSmallestMissingNumber function here
function findSmallestMissingNumber(arr) {
let left = 0;
let right = arr.length - 1;
while (left <= right) {
let mid = Math.floor((left + right) / 2);
if (arr[mid] > mid) {
right = mid - 1;
} else {
left = mid + 1;
}
}
return left;
}
</script>
</body>
</html>


The time complexity of this approach is also O(log n), the same as the binary search approach.

This approach is more efficient than the linear search approach and requires the array to be sorted.

## Conclusion

In this blog, we have talked about four ways of finding the smallest missing number from an array. Those are the naive approach, binary search approach, linear search approach, and modified binary search approach.

Updated on: 10-Apr-2023

167 Views

##### Kickstart Your Career

Get certified by completing the course

Advertisements