Added complexity tags 138-160

Author: javadev

src.save/main/java/g0101_0200/s0138_copy_list_with_random_pointer/Solution.java

@@ -1,7 +1,7 @@
 package g0101_0200.s0138_copy_list_with_random_pointer;
 
 // #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Hash_Table #Linked_List
-// #Programming_Skills_II_Day_14 #Udemy_Linked_List
+// #Programming_Skills_II_Day_14 #Udemy_Linked_List #Big_O_Time_O(N)_Space_O(N)
 // #2022_06_24_Time_0_ms_(100.00%)_Space_45.5_MB_(56.49%)
 
 import com_github_leetcode.random.Node;

src.save/main/java/g0101_0200/s0138_copy_list_with_random_pointer/complexity.md

@@ -0,0 +1,23 @@
+**Time Complexity (Big O Time):**
+
+1. **First Pass**: In the first pass, the program iterates through the original linked list and creates a cloned node for each node in the original list. This operation takes O(N) time, where N is the number of nodes in the original list, as it processes each node once.
+
+2. **Second Pass**: In the second pass, the program updates the random pointers of the cloned nodes based on the random pointers of the original nodes. This operation also takes O(N) time since it processes each node once.
+
+3. **Third Pass**: In the third pass, the program separates the cloned linked list from the original linked list and restores the original linked list's next pointers. This final pass also takes O(N) time, as it processes each node once.
+
+Overall, the time complexity of the program is O(N), where N is the number of nodes in the linked list. All three passes contribute linearly to the time complexity.
+
+**Space Complexity (Big O Space):**
+
+The space complexity of the program is O(N), where N is the number of nodes in the linked list. Here's how the space is allocated:
+
+1. **Cloned Nodes**: During the first pass, the program creates cloned nodes for each node in the original linked list. This results in N additional nodes, each taking constant space. Therefore, the space used for the cloned nodes is O(N).
+
+2. **Random Pointers**: No additional space is used for random pointers since the program manipulates the existing nodes in the original linked list to connect to their corresponding cloned nodes.
+
+3. **New Head Node**: A single variable `newHead` is used to store the head of the cloned linked list. This variable takes constant space.
+
+4. **Other Variables**: The program uses a few additional variables (`curr`, `clonedNode`) to traverse and manipulate the linked list. These variables take constant space.
+
+Overall, the space complexity is O(N) due to the cloned nodes created during the first pass, which directly corresponds to the number of nodes in the linked list.

src.save/main/java/g0101_0200/s0139_word_break/Solution.java

@@ -2,7 +2,7 @@
 
 // #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Hash_Table
 // #Dynamic_Programming #Trie #Memoization #Algorithm_II_Day_15_Dynamic_Programming
-// #Dynamic_Programming_I_Day_9 #Udemy_Dynamic_Programming
+// #Dynamic_Programming_I_Day_9 #Udemy_Dynamic_Programming #Big_O_Time_O(M+max*N)_Space_O(M+N+max)
 // #2022_06_24_Time_2_ms_(97.08%)_Space_42.1_MB_(90.92%)
 
 import java.util.HashSet;

src.save/main/java/g0101_0200/s0139_word_break/complexity.md

@@ -0,0 +1,23 @@
+**Time Complexity (Big O Time):**
+
+- **HashSet Initialization**: Initializing the `HashSet` with the words from the `wordDict` takes O(M) time, where M is the total length of all words in the dictionary.
+
+- **Maximum Length Calculation**: In the first loop, the program calculates the maximum word length in the `wordDict`. This takes O(M) time, as it iterates through all the words.
+
+- **DFS Function Calls**: The main work is done in the `dfs` function. The function is called multiple times with different `end` values (from 1 to the maximum word length). The number of calls depends on the maximum word length, which we denoted as "max." Therefore, the time complexity of the DFS portion is O(max * N), where N is the length of the input string `s`.
+
+- **Flag Array**: The program uses a `flag` array to memoize subproblem results to avoid redundant work. Initializing this array takes O(N) time since it has a length equal to the length of the input string `s`.
+
+Combining these steps, the overall time complexity of the program is O(M + max * N), where M is the total length of all words in the dictionary, N is the length of the input string `s`, and max is the maximum word length in the dictionary.
+
+**Space Complexity (Big O Space):**
+
+- **HashSet Space**: The `HashSet` `set` is used to store the words from the dictionary. It consumes O(M) space, where M is the total length of all words in the dictionary.
+
+- **Flag Array**: The `flag` array is used for memoization, and it has a length equal to the length of the input string `s`, so it consumes O(N) space.
+
+- **DFS Recursive Calls**: The depth of the recursive calls in the `dfs` function can go up to "max," where "max" is the maximum word length in the dictionary. This contributes to the call stack space. Therefore, in the worst case, the space complexity due to recursive calls is O(max).
+
+Combining these space requirements, the overall space complexity of the program is O(M + N + max).
+
+In summary, the time complexity is O(M + max * N), and the space complexity is O(M + N + max), where M is the total length of all words in the dictionary, N is the length of the input string `s`, and max is the maximum word length in the dictionary.

src.save/main/java/g0101_0200/s0141_linked_list_cycle/Solution.java

@@ -1,7 +1,7 @@
 package g0101_0200.s0141_linked_list_cycle;
 
 // #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Hash_Table #Two_Pointers #Linked_List
-// #Data_Structure_I_Day_7_Linked_List #Udemy_Linked_List
+// #Data_Structure_I_Day_7_Linked_List #Udemy_Linked_List #Big_O_Time_O(N)_Space_O(1)
 // #2022_06_24_Time_0_ms_(100.00%)_Space_45.5_MB_(68.52%)
 
 import com_github_leetcode.ListNode;

src.save/main/java/g0101_0200/s0141_linked_list_cycle/complexity.md

@@ -0,0 +1,14 @@
+**Time Complexity (Big O Time):**
+
+- The program uses two pointers, `fast` and `slow`, to traverse the linked list.
+- The `fast` pointer moves twice as fast as the `slow` pointer in each iteration.
+
+The key insight here is that if there is a cycle in the linked list, the `fast` and `slow` pointers will eventually meet (i.e., `fast == slow`). If there is no cycle, the `fast` pointer will reach the end of the list (i.e., `fast == null` or `fast.next == null`) before the `slow` pointer.
+
+Therefore, the time complexity of this algorithm is O(N), where N is the number of nodes in the linked list. This is because in the worst case, when there is no cycle, both pointers will traverse the entire linked list once.
+
+**Space Complexity (Big O Space):**
+
+The space complexity of this algorithm is O(1), which means it uses a constant amount of extra space regardless of the size of the input linked list. This is because it only uses two additional pointers (`fast` and `slow`) to traverse the list and does not rely on additional data structures or recursion that would consume additional memory.
+
+In summary, the time complexity of this program is O(N), and the space complexity is O(1), where N is the number of nodes in the linked list.

src.save/main/java/g0101_0200/s0142_linked_list_cycle_ii/Solution.java

@@ -2,7 +2,7 @@
 
 // #Medium #Top_100_Liked_Questions #Hash_Table #Two_Pointers #Linked_List
 // #Data_Structure_II_Day_10_Linked_List #Level_1_Day_4_Linked_List #Udemy_Linked_List
-// #2022_06_24_Time_0_ms_(100.00%)_Space_42.3_MB_(98.70%)
+// #Big_O_Time_O(N)_Space_O(1) #2022_06_24_Time_0_ms_(100.00%)_Space_42.3_MB_(98.70%)
 
 import com_github_leetcode.ListNode;
 

src.save/main/java/g0101_0200/s0142_linked_list_cycle_ii/complexity.md

@@ -0,0 +1,18 @@
+**Time Complexity (Big O Time):**
+
+- The program uses two pointers, `fast` and `slow`, to traverse the linked list.
+- The first while loop is used to determine if there is a cycle and find the meeting point of `fast` and `slow`. This loop runs until `fast` and `slow` meet inside the loop or reach the end of the list.
+
+If there is no cycle, both pointers will reach the end of the list in O(N) time, where N is the number of nodes in the linked list.
+
+If there is a cycle, the `fast` and `slow` pointers will meet inside the loop. The maximum number of iterations needed to detect the cycle and find the meeting point is less than or equal to N. Therefore, the time complexity remains O(N).
+
+The second while loop is used to find the starting node of the cycle. It starts from the head of the list and moves `slow` and `fast` pointers at the same speed until they meet at the starting node of the cycle. This loop runs in O(N) time.
+
+Overall, the time complexity of this algorithm is O(N).
+
+**Space Complexity (Big O Space):**
+
+The space complexity of this algorithm is O(1), which means it uses a constant amount of extra space regardless of the size of the input linked list. It only uses a few additional pointers (`fast` and `slow`) to traverse the list and does not rely on additional data structures or recursion that would consume additional memory.
+
+In summary, the time complexity of this program is O(N), and the space complexity is O(1), where N is the number of nodes in the linked list.

src.save/main/java/g0101_0200/s0146_lru_cache/LRUCache.java

@@ -1,7 +1,8 @@
 package g0101_0200.s0146_lru_cache;
 
 // #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Hash_Table #Design #Linked_List
-// #Doubly_Linked_List #Udemy_Linked_List #2022_06_24_Time_87_ms_(50.80%)_Space_125.2_MB_(58.73%)
+// #Doubly_Linked_List #Udemy_Linked_List #Big_O_Time_O(1)_Space_O(capacity)
+// #2022_06_24_Time_87_ms_(50.80%)_Space_125.2_MB_(58.73%)
 
 import java.util.HashMap;
 import java.util.Map;

src.save/main/java/g0101_0200/s0146_lru_cache/complexity.md

@@ -0,0 +1,25 @@
+**Time Complexity (Big O Time):**
+
+1. `get(int key)` Method:
+   - Accessing an element from the `cacheMap` is done in constant time (O(1)).
+   - Moving a node to the head in the `moveToHead` method also operates in constant time (O(1)).
+   - Overall, the `get` method's time complexity is O(1).
+
+2. `put(int key, int value)` Method:
+   - Updating the value of an existing key in the `cacheMap` is done in constant time (O(1)).
+   - Adding a new node to the cache is done in constant time if the cache is not full (O(1)).
+   - If the cache is full, it removes the node at the tail, which is also done in constant time (O(1)).
+   - Recursively calling the `put` method when the cache is full does not result in nested loops because the eviction operation happens once in each recursion.
+   - Overall, the `put` method's time complexity is O(1) on average, but in the worst case (when eviction happens multiple times), it can be considered O(N), where N is the capacity of the cache.
+
+3. `moveToHead(LruCacheNode node)` Method:
+   - Moving a node to the head of the cache is done in constant time (O(1)) because it involves changing pointers.
+   - The time complexity of this method is O(1).
+
+Overall, the time complexity of most operations in the LRU cache is O(1), except for the `put` method in the worst-case scenario.
+
+**Space Complexity (Big O Space):**
+
+The space complexity of this LRU cache implementation is O(capacity), where "capacity" represents the maximum number of key-value pairs the cache can store. The primary space usage comes from the `cacheMap`, which stores the key-value pairs, and the linked list of nodes (`head` and `tail`) used to maintain the order of access. Additionally, each node in the linked list consumes space proportional to the key and value sizes.
+
+In summary, the space complexity of the LRU cache is determined by its capacity, and the primary space-consuming data structure is the `cacheMap`, resulting in an overall space complexity of O(capacity).