Article Categories
- All Categories
-
Data Structure
-
Networking
-
RDBMS
-
Operating System
-
Java
-
MS Excel
-
iOS
-
HTML
-
CSS
-
Android
-
Python
-
C Programming
-
C++
-
C#
-
MongoDB
-
MySQL
-
Javascript
-
PHP
-
Economics & Finance
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: Linear Scan 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>
4
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 key insight is that if arr[i] == i, then all elements from 0 to i are present.
Example
<!DOCTYPE html>
<html>
<body>
<div id="result"></div>
<script>
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;
}
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>
Array: [0,1,2,3,4,5,6,8] The smallest missing number is: 7
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 linear approach as it takes advantage of the fact that the array is sorted.
Method 3: Starting from 1 (Non-Zero Based)
Sometimes the array starts from 1 instead of 0. In such cases, we need to modify our approach slightly. We compare each element with (index + 1) instead of just the index.
Example
The code for handling arrays that start from 1 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>
4
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: Optimized Binary Search
This is the most efficient approach that uses binary search optimally. The basic idea is to divide the array in half at every step and compare the middle element with its expected value at that position.
Example
Here is the code implementation of the optimized 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>
const inputArray = [0, 1, 2, 3, 4, 6, 7, 8];
document.getElementById("inputArray").innerHTML = JSON.stringify(inputArray);
function findMissingNumber() {
const result = findSmallestMissingNumber(inputArray);
document.getElementById("result").innerHTML = `The smallest missing number is: ${result}`;
}
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>
[0,1,2,3,4,6,7,8] The smallest missing number is: 5
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.
Comparison
| Method | Time Complexity | Space Complexity | Best Use Case |
|---|---|---|---|
| Linear Scan | O(n) | O(1) | Small arrays or unsorted data |
| Binary Search | O(log n) | O(1) | Large sorted arrays |
| Non-Zero Based | O(n) | O(1) | Arrays starting from 1 |
| Optimized Binary Search | O(log n) | O(1) | Most efficient for sorted arrays |
Conclusion
In this tutorial, we explored four different approaches to find the smallest missing number from a sorted array. The binary search approaches (Methods 2 and 4) are most efficient with O(log n) complexity, while linear approaches work well for smaller datasets or when the array isn't guaranteed to be sorted.
454 Views
