• Home
• com.github.javadev
• leetcode-in-java21
• 1.25
• 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.

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

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

1. The program uses a recursive approach to generate subsets. It starts with an empty subset and adds elements from the input array `nums` one by one.
   
2. Inside the `solve` function, there's a loop that iterates from `start` to the length of the `nums` array. In each iteration, it adds an element to the `temp` list, calls the `solve` function recursively, and then removes the added element from `temp`.

3. The recursive `solve` function is called for each element in the `nums` array, and each time it adds the current subset to the result list `res`. Therefore, the function is called 2^n times, where 'n' is the length of the `nums` array, because for each element, there are two choices: either include it in the current subset or exclude it.

4. Inside the loop, the operations performed (addition, recursion, removal) are constant time operations.

5. As a result, the overall time complexity of the program is O(2^n), where 'n' is the length of the input array `nums`. This is because it generates all possible subsets of the input array.

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

1. The space complexity is primarily determined by the space used for the result list `res` and the recursive call stack.

2. The result list `res` stores all the subsets. In the worst case, when `nums` contains 'n' elements, there can be 2^n subsets (including the empty subset). Each subset is a list of integers containing at most 'n' elements. Therefore, the space complexity for `res` is O(2^n * n), which simplifies to O(n * 2^n).

3. The space used by the recursive call stack depends on the depth of the recursion, which is at most 'n' (the number of elements in `nums`). For each recursive call, a constant amount of space is used to store the `temp` list. Therefore, the space complexity due to the call stack is O(n).

4. Combining the space complexities of the result list and the call stack, the overall space complexity is O(n * 2^n).

In summary, the time complexity of the program is O(2^n), and the space complexity is O(n * 2^n), where 'n' is the length of the input array `nums`. This program efficiently generates all possible subsets of `nums` using a recursive approach.