g0201_0300.s0226_invert_binary_tree.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-java21 Show documentation
Show all versions of leetcode-in-java21 Show documentation
Java-based LeetCode algorithm problem solutions, regularly updated
**Time Complexity (Big O Time):**
The time complexity of this program can be analyzed based on the number of nodes in the binary tree.
1. **Traversal and Swapping:**
- The program recursively traverses each node of the binary tree exactly once.
- At each node, it swaps the left and right subtrees.
- Therefore, the time complexity is O(n), where "n" is the number of nodes in the binary tree.
**Space Complexity (Big O Space):**
The space complexity of this program is determined by the recursion stack and the memory required for the TreeNode objects.
1. **Recursion Stack:**
- The program uses recursion to traverse the binary tree.
- The maximum depth of the recursion stack is equal to the height of the binary tree.
- In the worst case, if the binary tree is completely unbalanced (skewed), the height could be "n" (the number of nodes), resulting in O(n) space complexity.
- In the best case, if the binary tree is balanced, the height would be approximately log₂(n), resulting in O(log n) space complexity.
2. **TreeNode Objects:**
- The program doesn't use additional data structures or collections that grow with the input size.
- The TreeNode objects exist in memory for each node in the binary tree.
- The space required for TreeNode objects is O(n) in the worst case, where "n" is the number of nodes in the binary tree.
In summary, the space complexity is O(n) due to the recursion stack and the TreeNode objects, and the time complexity is O(n) as it visits each node once during the traversal and swapping process.