Unit 8 Session 2 Standard (Click for link to problem statements)
Unit 8 Session 2 Advanced (Click for link to problem statements)
Understand what the interviewer is asking for by using test cases and questions about the problem.
- Established a set (2-3) of test cases to verify their own solution later.
- Established a set (1-2) of edge cases to verify their solution handles complexities.
- Have fully understood the problem and have no clarifying questions.
- Have you verified any Time/Space Constraints for this problem?
HAPPY CASE
Input:
collection = TreeNode("Monstera",
TreeNode("MoneyTree", None, TreeNode("Pothos")),
TreeNode("Pilea", TreeNode("Hoya"), TreeNode("Ivy"))),
name = "Pilea"
Output: Updated BST with "Pilea" removed, replaced by its inorder predecessor.
Explanation: "Pilea" has two children, so it's replaced by the inorder predecessor "Hoya".
EDGE CASE
Input:
collection = TreeNode("Monstera",
TreeNode("MoneyTree", None, TreeNode("Pothos")),
TreeNode("Pilea", TreeNode("Hoya"), TreeNode("Ivy"))),
name = "Monstera"
Output: Updated BST with "Monstera" removed, replaced by its inorder predecessor.
Explanation: "Monstera" is the root with two children, so it's replaced by the inorder predecessor "Pilea".
Match what this problem looks like to known categories of problems, e.g., Linked List or Dynamic Programming, and strategies or patterns in those categories.
For Binary Search Tree (BST) problems, we want to consider the following approaches:
Plan the solution with appropriate visualizations and pseudocode.
General Idea: Traverse the BST to find the node to remove. Handle the different cases based on the node's children, and update the tree accordingly.
1) If the current node (`collection`) is `None`, return `None`.
2) If `name` is less than the current node's value, recurse on the left subtree.
3) If `name` is greater than the current node's value, recurse on the right subtree.
4) If `name` matches the current node's value:
- If the node has no children, return `None`.
- If the node has one child, return that child.
- If the node has two children:
- Find the inorder predecessor (rightmost node in the left subtree).
- Replace the current node's value with the inorder predecessor's value.
- Recursively remove the inorder predecessor from the left subtree.
5) Return the root of the updated tree.
⚠️ Common Mistakes
Implement the code to solve the algorithm.
class TreeNode:
def __init__(self, value, left=None, right=None):
self.val = value
self.left = left
self.right = right
def remove_plant(collection, name):
if collection is None:
return collection
# Step 1: Find the node to be removed
if name < collection.val:
collection.left = remove_plant(collection.left, name)
elif name > collection.val:
collection.right = remove_plant(collection.right, name)
else:
# Node with the same name found
# Step 2: Node has no children (leaf node)
if collection.left is None and collection.right is None:
return None
# Step 3: Node has one child
if collection.left is None:
return collection.right
elif collection.right is None:
return collection.left
# Step 4: Node has two children
# Find the inorder predecessor (rightmost node in the left subtree)
predecessor = max_value_node(collection.left)
# Replace the node's value with the predecessor's value
collection.val = predecessor.val
# Remove the inorder predecessor
collection.left = remove_plant(collection.left, predecessor.val)
return collection
def max_value_node(node):
current = node
while current.right:
current = current.right
return current
Review the code by running specific example(s) and recording values (watchlist) of your code's variables along the way.
- Example 1:
- Input:
`collection = TreeNode("Monstera", TreeNode("MoneyTree", None, TreeNode("Pothos")), TreeNode("Pilea", TreeNode("Hoya"), TreeNode("Ivy")))`
`name = "Pilea"`
- Execution:
- Start at root "Monstera".
- "Pilea" > "Monstera", move to the right child "Pilea".
- Node "Pilea" found with two children, find inorder predecessor "Hoya".
- Replace "Pilea" with "Hoya" and remove "Hoya".
- Output:
```
Monstera
MoneyTree Hoya
Pothos Ivy
```
- Example 2:
- Input:
`collection = TreeNode("Monstera", TreeNode("MoneyTree", None, TreeNode("Pothos")), TreeNode("Pilea", TreeNode("Hoya"), TreeNode("Ivy")))`
`name = "Monstera"`
- Execution:
- Start at root "Monstera".
- Node "Monstera" found with two children, find inorder predecessor "Pilea".
- Replace "Monstera" with "Pilea" and remove "Pilea".
- Output:
```
Pilea
MoneyTree Hoya
Pothos Ivy
```
Evaluate the performance of your algorithm and state any strong/weak or future potential work.
Assume N
represents the number of nodes in the tree.
O(H)
where H
is the height of the tree. In a balanced BST, this is O(log N)
.O(H)
due to the recursive call stack. In the worst case for a skewed tree, this could be O(N)
.