• Home
• com.github.javadev
• leetcode-in-java
• 1.38
• source code
• complexity.md

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

g0101_0200.s0128_longest_consecutive_sequence.complexity.md Maven / Gradle / Ivy

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

1. The program begins by checking if the input array `nums` is empty. This operation is done in constant time and does not depend on the size of the array. Therefore, it can be considered O(1).

2. The program then sorts the `nums` array using `Arrays.sort()`. The time complexity of the sorting operation is O(N log N), where N is the number of elements in the array. This is the most time-consuming operation in the program.

3. After sorting, the program iterates through the sorted array once, comparing adjacent elements. The loop runs from `i = 0` to `i < nums.length - 1`. In each iteration, it checks if `nums[i + 1]` is consecutive to `nums[i]` and updates the `thsMax` variable accordingly. This loop is a linear pass over the sorted array and runs in O(N) time.

4. The program uses a few constant-time operations such as comparisons and updates within the loop.

5. Finally, the program returns the maximum of `max` and `thsMax`. This operation is done in constant time.

Therefore, the overall time complexity of the program is dominated by the sorting step, which is O(N log N) due to the use of `Arrays.sort()`.

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

1. The space complexity of the program is determined by the space required for the input `nums` array and a few integer variables (`max` and `thsMax`) that occupy constant space regardless of the input size. Therefore, the space complexity is O(1), as it does not depend on the size of the input array.

In summary, the time complexity of the program is O(N log N) due to the sorting operation, and the space complexity is O(1) because it uses only a constant amount of additional space.