Find The Smallest Positive Integer That Does Not Occur in A Given Sequence

The problem is as follows: when given a sequence of integers, you are supposed to identify the smallest positive integer missing in the given sequence of numbers. There are also likely to be repeated elements in the sequence, as well as negative numbers or even zeros, but the focus here will be on the positive whole numbers only.

Approach 1: Using for-Loop

Sort the sequence: Arranging the sequence helps to know which integer is missing most of the time when the numbers are arranged in an ascending or descending order.

Iterate through the sorted sequence: Making the first step equal to the least positive integer or 1, look at each element in the sorted sequence.

Identify the gap: When one fails to find the current smallest integer in this sequence, then such an integer is missing.

File Name: SmallestMissingInteger.java

 
import java.util.Arrays;
public class SmallestMissingInteger {
    public static int findMissingInteger(int[] arr) {
        Arrays.sort(arr); // Step 1: Sort the array
        int smallestMissing = 1;
        for (int num : arr) { // Step 2: Iterate through the array
            if (num == smallestMissing) {
                smallestMissing++; // Step 3: Move to the next integer if found
            }
        }
        return smallestMissing; // Return the smallest missing positive integer
    }
    public static void main(String[] args) {
        int[] arr = {3, 4, -1, 1};
        System.out.println(findMissingInteger(arr)); // Output: 2
    }
}   

Output:

Approach 2: Using Map-Function

Create a Map (or hash table): Utilise a map to store the occurrence of each positive integer.

Map the Elements: Cross off each integer on the list as the number is called out, using the positive integers only in the count.

Find the Missing Integer: Begin from 1 and on the map, locate the first missing integer.

File Name: SmallestMissingInteger.java

 
import java.util.HashMap;
public class SmallestMissingInteger {
    public static int findMissingInteger(int[] arr) {
        HashMap<Integer, Boolean> map = new HashMap<>();
        for (int num : arr) { // Step 2: Map the elements
            if (num > 0) {
                map.put(num, true);
            }
        }
        int smallestMissing = 1;
        while (map.containsKey(smallestMissing)) { // Step 3: Find the missing integer
            smallestMissing++;
        }
        return smallestMissing;
    }
    public static void main(String[] args) {
        int[] arr = {3, 4, -1, 1};
        System.out.println(findMissingInteger(arr)); // Output: 2
    }
}   

Output:

Approach 3: Using Set

A set gives an opportunity to determine if an element is contained in the set in O(1) time complexity.

Add elements to the set: Now let the sequence be iterated through so as to include all positive integers in the set.

Identify the smallest missing integer: Start counting from 1 and counting until you reach a number that is not on the set.

File Name: SmallestMissingInteger.java

 
import java.util.HashSet;
public class SmallestMissingInteger {
    public static int findMissingInteger(int[] arr) {
        HashSet<Integer> set = new HashSet<>();
        for (int num : arr) { // Step 2: Add elements to the set
            if (num > 0) {
                set.add(num);
            }
        }
        int smallestMissing = 1;
        while (set.contains(smallestMissing)) { // Step 3: Identify the smallest missing integer
            smallestMissing++;
        }
        return smallestMissing;
    }
    public static void main(String[] args) {
        int[] arr = {3, 4, -1, 1};
        System.out.println(findMissingInteger(arr)); // Output: 2
    }
}   

Output:

Efficiency and Performance

For-Loop Approach: The worst-case time complexity of the algorithm is n log n because of the sorting step, while the space complexity is O(1) because no extra space was used.
Map-Function Approach: Time complexity is O(n), but the space complexity also can be O(n) because of the map.
Set Approach: The time complexity is n, and the space complexity is n, as in the map-based approach, though possibly with less overhead.

Conclusion

Each approach can be used to solve the problem, yet it strictly depends on the situation involved in the issue. It is simple and space-efficient, but the time needed is high because of sorting operations, so it is not suitable for significant inputs.

Indeed, the map and set approaches are more efficient in terms of time - they are implemented according to the `O(n)` time complexity but use more memory. Hence, these approaches are appropriate when used within systems whose operational speed is of the essence and where the use of memory is not an issue.

The for-loop approach is practical for relatively small data sets, or where memory optimization matters a lot. Therefore, the decision on the right approach should be hinged on the input size and the environment within which the operations of the algorithm would be conducted.

Next TopicImage-processing-in-java-colored-image-to-sepia-image-conversion

← prev next →