g0001_0100.s0041_first_missing_positive.complexity.md Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java Show documentation

Java-based LeetCode algorithm problem solutions, regularly updated

The newest version!

**Time Complexity (Big O Time):**

1. The program contains two loops:
   - The first loop iterates through the array `nums` once to perform a depth-first search (DFS) on the elements.
   - The second loop iterates through the modified `nums` array once to find the first missing positive integer.

2. In the worst case, the first loop may visit every element in the `nums` array, which has a length of n (the number of elements in the array).

3. The DFS recursion also runs in the worst case for every element in the array. In the worst case, the recursion depth could be n (for example, if the array contains all positive integers from 1 to n).

4. The second loop always iterates through the entire array once.

5. Therefore, the overall time complexity of the program is O(n), where n is the length of the input array `nums`.

**Space Complexity (Big O Space):**

1. The space complexity of the program is determined by the space used for the call stack during the DFS recursion and the constant space used for variables.

2. The maximum depth of the DFS recursion is bounded by n in the worst case (when the array contains all positive integers from 1 to n). Therefore, the space used for the call stack is O(n).

3. The program uses a few integer variables (`i`, `val`, `temp`) and does not use any additional data structures that scale with the input size.

4. Therefore, the overall space complexity of the program is O(n) due to the space used for the call stack, where n is the length of the input array `nums`.

In summary, the time complexity of the provided program is O(n), and the space complexity is O(n), where n is the number of elements in the input array `nums`.