Added complexity tags 101-136

Author: javadev

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

@@ -2,7 +2,7 @@
 
 // #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Depth_First_Search #Breadth_First_Search
 // #Tree #Binary_Tree #Data_Structure_I_Day_11_Tree #Level_2_Day_15_Tree
-// #2022_06_22_Time_0_ms_(100.00%)_Space_42.3_MB_(46.67%)
+// #Big_O_Time_O(N)_Space_O(log(N)) #2022_06_22_Time_0_ms_(100.00%)_Space_42.3_MB_(46.67%)
 
 import com_github_leetcode.TreeNode;
 

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

@@ -0,0 +1,23 @@
+**Time Complexity (Big O Time):**
+
+The program uses a recursive approach to check if the binary tree is symmetric. It recursively compares the left subtree of the root with the right subtree of the root. Here's the analysis of time complexity:
+
+- In the worst case, the program visits each node once. This happens when the tree is perfectly symmetric (a mirror image of itself), and the program checks every node.
+
+- Therefore, the time complexity of this program is O(N), where N is the number of nodes in the binary tree.
+
+**Space Complexity (Big O Space):**
+
+The space complexity of the program is determined by the space required for the recursive call stack and the space needed for the function arguments and variables. Here's the analysis of space complexity:
+
+- The main function `isSymmetric` has a constant amount of space overhead. It doesn't use any additional data structures or arrays that depend on the input size.
+
+- The recursive function `helper` is called recursively for each pair of nodes in the tree. In the worst case, when the binary tree is perfectly symmetric, the maximum depth of the call stack is equal to the height of the tree. In a balanced tree, this height is log(N), where N is the number of nodes.
+
+- Therefore, the space complexity due to the call stack is O(log(N)) in the best-case scenario (balanced tree) and O(N) in the worst-case scenario (skewed tree).
+
+- The space used for function arguments and variables (e.g., `leftNode`, `rightNode`) is constant and does not depend on the input size.
+
+- Overall, the space complexity of the program is O(log(N)) in the best-case scenario and O(N) in the worst-case scenario. The space complexity is mainly determined by the depth of the call stack when checking a perfectly symmetric tree.
+
+In summary, the time complexity of the program is O(N), where N is the number of nodes in the binary tree, and the space complexity is O(log(N)) in the best-case scenario (perfectly symmetric tree) and O(N) in the worst-case scenario (skewed tree). The space complexity is primarily determined by the depth of the call stack when checking a symmetric tree.

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

@@ -2,7 +2,7 @@
 
 // #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Breadth_First_Search #Tree
 // #Binary_Tree #Data_Structure_I_Day_11_Tree #Level_1_Day_6_Tree #Udemy_Tree_Stack_Queue
-// #2022_06_22_Time_1_ms_(91.09%)_Space_43.6_MB_(42.50%)
+// #Big_O_Time_O(N)_Space_O(N) #2022_06_22_Time_1_ms_(91.09%)_Space_43.6_MB_(42.50%)
 
 import com_github_leetcode.TreeNode;
 import java.util.ArrayList;

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

@@ -0,0 +1,25 @@
+**Time Complexity (Big O Time):**
+
+The program uses a level order traversal approach, which visits each node once, and each edge is traversed exactly twice (once from parent to child and once from child to parent). Here's the analysis of time complexity:
+
+- In the worst case, when the binary tree is completely unbalanced (e.g., a skewed tree), the program needs to visit all N nodes in the tree.
+
+- During the traversal, the program processes each node once and performs constant-time operations (addition and removal from the queue) for each node.
+
+- Therefore, the time complexity of this program is O(N), where N is the number of nodes in the binary tree.
+
+**Space Complexity (Big O Space):**
+
+The space complexity of the program is determined by the space required for data structures, specifically the queue used for the level order traversal, and the space needed for the output list of lists. Here's the analysis of space complexity:
+
+- The program uses a queue to perform level order traversal. In the worst case, when the binary tree is completely unbalanced (e.g., a skewed tree), the queue can contain all N nodes in the tree. Therefore, the space complexity due to the queue is O(N).
+
+- The program constructs a list of lists (`result`) to store the level order traversal result. In the worst case, the result list can contain N/2 lists (for a completely unbalanced tree), each with an average of 2 elements (at the lowest level of the tree).
+
+- Therefore, the space complexity due to the `result` list is also O(N).
+
+- Additional space is used for temporary variables such as `level` and loop control variables, but this space is constant and does not depend on the input size.
+
+- Overall, the space complexity of the program is O(N) due to the space required for the queue and the level order traversal result.
+
+In summary, the time complexity of the program is O(N) because it visits each node once, and the space complexity is also O(N) due to the space required for the queue and the level order traversal result. The space complexity is primarily determined by the size of the queue when traversing a completely unbalanced tree.

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

@@ -3,7 +3,7 @@
 // #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Depth_First_Search #Breadth_First_Search
 // #Tree #Binary_Tree #Data_Structure_I_Day_11_Tree
 // #Programming_Skills_I_Day_10_Linked_List_and_Tree #Udemy_Tree_Stack_Queue
-// #2022_06_22_Time_0_ms_(100.00%)_Space_42.9_MB_(67.03%)
+// #Big_O_Time_O(N)_Space_O(H) #2022_06_22_Time_0_ms_(100.00%)_Space_42.9_MB_(67.03%)
 
 import com_github_leetcode.TreeNode;
 

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

@@ -0,0 +1,25 @@
+**Time Complexity (Big O Time):**
+
+The program uses a recursive approach to traverse the binary tree and find its maximum depth. The time complexity can be analyzed as follows:
+
+- In the worst case, when the binary tree is completely unbalanced (e.g., a skewed tree), the program needs to visit all N nodes in the tree.
+
+- The program processes each node exactly once and performs constant-time operations (addition and comparison) for each node.
+
+- Therefore, the time complexity of this program is O(N), where N is the number of nodes in the binary tree.
+
+**Space Complexity (Big O Space):**
+
+The space complexity of the program is determined by the space required for the recursive function call stack. Here's the analysis of space complexity:
+
+- The program uses a recursive function `findDepth` to traverse the binary tree. In the worst case, when the binary tree is completely unbalanced (e.g., a skewed tree), the maximum depth of the call stack can be equal to the height of the tree.
+
+- For a balanced binary tree, the maximum depth of the call stack is proportional to the logarithm of the number of nodes (log₂(N)), which is the height of a balanced binary tree.
+
+- Therefore, the space complexity due to the call stack is O(H), where H is the height of the binary tree.
+
+- Additional space is used for the function's local variables, but this space is constant and does not depend on the input size.
+
+- Overall, the space complexity of the program is O(H), where H is the height of the binary tree, and it represents the maximum depth of the call stack during the recursive traversal.
+
+In summary, the time complexity of the program is O(N) because it visits each node once, and the space complexity is O(H), where H is the height of the binary tree. The space complexity is primarily determined by the maximum depth of the call stack, which can vary depending on the shape of the tree.

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

@@ -1,7 +1,7 @@
 package g0101_0200.s0105_construct_binary_tree_from_preorder_and_inorder_traversal;
 
 // #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Hash_Table #Tree #Binary_Tree
-// #Divide_and_Conquer #Data_Structure_II_Day_15_Tree
+// #Divide_and_Conquer #Data_Structure_II_Day_15_Tree #Big_O_Time_O(N)_Space_O(N)
 // #2022_06_22_Time_3_ms_(86.35%)_Space_45.2_MB_(14.09%)
 
 import com_github_leetcode.TreeNode;

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

@@ -0,0 +1,27 @@
+**Time Complexity (Big O Time):**
+
+The time complexity of the program can be analyzed as follows:
+
+- The `buildTree` function initializes a map (`map`) and populates it with values from the `inorder` array. The population process takes O(N) time, where N is the number of nodes in the binary tree.
+
+- The `answer` function is a recursive function that constructs the binary tree. It uses the `preorder` array to determine the root of the current subtree. For each subtree, it finds the index of the root value in the `inorder` array using the `map`. This operation takes O(1) time.
+
+- In each recursive call, the program divides the problem into two subproblems: constructing the left subtree and constructing the right subtree. The division and recursive calls are performed for each node in the tree.
+
+- Since each node is processed once in the recursive calls, and there are N nodes in the binary tree, the overall time complexity of the program is O(N).
+
+**Space Complexity (Big O Space):**
+
+The space complexity of the program is determined by the space required for data structures and the call stack. Here's the analysis of space complexity:
+
+- The `map` data structure is used to store mappings between values and their indices in the `inorder` array. The space used by this map is proportional to the number of nodes in the binary tree, which is O(N).
+
+- The recursive function `answer` utilizes the call stack to keep track of the recursive calls. In the worst case, when the binary tree is completely unbalanced (e.g., a skewed tree), the maximum depth of the call stack can be equal to the height of the tree, which is N in the worst case.
+
+- Therefore, the space complexity due to the call stack is O(N) in the worst case.
+
+- Additionally, there are a few integer variables and temporary variables used in the program. However, the space used by these variables is constant and does not depend on the input size.
+
+- Overall, the space complexity of the program is O(N) due to the map and the call stack.
+
+In summary, the time complexity of the program is O(N), and the space complexity is O(N) in the worst case. The space complexity is primarily determined by the map and the maximum depth of the call stack during the recursive construction of the binary tree.

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

@@ -1,7 +1,8 @@
 package g0101_0200.s0114_flatten_binary_tree_to_linked_list;
 
 // #Medium #Top_100_Liked_Questions #Depth_First_Search #Tree #Binary_Tree #Stack #Linked_List
-// #Udemy_Linked_List #2022_06_23_Time_1_ms_(75.27%)_Space_42.8_MB_(36.48%)
+// #Udemy_Linked_List #Big_O_Time_O(N)_Space_O(N)
+// #2022_06_23_Time_1_ms_(75.27%)_Space_42.8_MB_(36.48%)
 
 import com_github_leetcode.TreeNode;
 

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

@@ -0,0 +1,25 @@
+**Time Complexity (Big O Time):**
+
+The time complexity of the program can be analyzed as follows:
+
+- The `flatten` function is called once with the root of the binary tree, and it, in turn, calls the `findTail` function recursively.
+
+- The `findTail` function is a recursive function that traverses the left subtree of the current node and connects the right subtree to the left subtree to flatten the tree.
+
+- In the worst case, the `findTail` function is called for each node in the binary tree exactly once. Each recursive call of `findTail` takes constant time O(1) for node manipulations.
+
+- Therefore, the overall time complexity of the program is O(N), where N is the number of nodes in the binary tree.
+
+**Space Complexity (Big O Space):**
+
+The space complexity of the program is determined by the space required for the recursive call stack and the space for temporary variables. Here's the analysis of space complexity:
+
+- The primary factor contributing to space complexity is the recursive call stack. In the worst case, when the binary tree is completely unbalanced (e.g., a skewed tree), the maximum depth of the call stack can be equal to the height of the tree, which is N in the worst case.
+
+- Additionally, the program uses a few temporary variables like `left`, `right`, and `tail`, which occupy constant space.
+
+- Therefore, the space complexity due to the call stack is O(N) in the worst case, and the space complexity due to temporary variables is constant O(1).
+
+- Overall, the space complexity of the program is O(N) due to the call stack, which can grow linearly with the number of nodes in the binary tree.
+
+In summary, the time complexity of the program is O(N), and the space complexity is O(N) in the worst case. The space complexity is primarily determined by the call stack depth during the recursive flattening of the binary tree.