LeetCode 701. Insert into a Binary Search Tree

raul-sauco · raul-sauco · commit 88f17e05c709 · 2023-02-19T08:57:49.000+01:00
diff --git a/README.md b/README.md
@@ -265,6 +265,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 | [684. Redundant Connection][lc684]                                                            | 🟠 Medium  | [![python](res/py.png)][lc684py]                                                             |
 | [692. Top K Frequent Words][lc692]                                                            | 🟠 Medium  | [![python](res/py.png)][lc692py]                                                             |
 | [695. Max Area of Island][lc695]                                                              | 🟠 Medium  | [![python](res/py.png)][lc695py]                                                             |
+| [701. Insert into a Binary Search Tree][lc701]                                                | 🟠 Medium  | [![python](res/py.png)][lc701py] [![rust](res/rs.png)][lc701rs]                              |
 | [703. Kth Largest Element in a Stream][lc703]                                                 | 🟢 Easy    | [![python](res/py.png)][lc703py]                                                             |
 | [704. Binary Search][lc704]                                                                   | 🟢 Easy    | [![python](res/py.png)][lc704py]                                                             |
 | [718. Maximum Length of Repeated Subarray][lc718]                                             | 🟠 Medium  | [![python](res/py.png)][lc718py]                                                             |
@@ -939,6 +940,9 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 [lc692py]: leetcode/top-k-frequent-words.py
 [lc695]: https://leetcode.com/problems/max-area-of-island/
 [lc695py]: leetcode/max-area-of-island.py
+[lc701]: https://leetcode.com/problems/insert-into-a-binary-search-tree/
+[lc701py]: leetcode/insert-into-a-binary-search-tree.py
+[lc701rs]: leetcode/insert-into-a-binary-search-tree.rs
 [lc703]: https://leetcode.com/problems/kth-largest-element-in-a-stream/
 [lc703py]: leetcode/kth-largest-element-in-a-stream.py
 [lc704]: https://leetcode.com/problems/binary-search/
diff --git a/algoexpert/max-profit-with-k-transactions.py b/algoexpert/max-profit-with-k-transactions.py
@@ -10,7 +10,7 @@
 
 
 # The max profit each day depends on the max profit the previous day,
-# wether we are holding stock or not, and the number of transactions
+# whether we are holding stock or not, and the number of transactions
 # that we have left.
 #
 # Time complexity: O(k*n) - The outer loop iterates over n positions
diff --git a/leetcode/bag-of-tokens.py b/leetcode/bag-of-tokens.py
@@ -26,7 +26,7 @@ def bagOfTokensScore(self, tokens: List[int], power: int) -> int:
         # We want to access both the smallest and biggest element,
         # sort the tokens and use a deque to store them.
         q = deque(sorted(tokens))
-        # Keep track of the length of the queue to determine wether we
+        # Keep track of the length of the queue to determine whether we
         # made a move on the last round.
         last_token_count = len(q) + 1
         # Keep going while we have tokens and we made a move on the last
diff --git a/leetcode/binary-tree-pruning.py b/leetcode/binary-tree-pruning.py
@@ -28,7 +28,7 @@ def pruneTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
         # Base case.
         if not root:
             return None
-        # DFS function returns wether the child contains a 1.
+        # DFS function returns whether the child contains a 1.
         def containsOne(node: TreeNode) -> bool:
             # Unlink the children if they exist and do not contain a 1.
             if node.left and not containsOne(node.left):
diff --git a/leetcode/determine-if-string-halves-are-alike.py b/leetcode/determine-if-string-halves-are-alike.py
@@ -7,7 +7,8 @@
 
 import timeit
 
-# Count the number of vowels in each half of the string, return wether
+
+# Count the number of vowels in each half of the string, return whether
 # the count is the same.
 #
 # Time complexity: O(n) - We visit all elements in the input and perform
diff --git a/leetcode/find-and-replace-pattern.py b/leetcode/find-and-replace-pattern.py
@@ -47,7 +47,7 @@ def findAndReplacePattern(
 
             # Mapping of the current word's characters to the pattern
             wd = {}
-            # Flag wether the character matches.
+            # Flag whether the character matches.
             match = True
             # Visit each character in word matching its characters with
             # its index the first time we see it. Then check if the
@@ -99,7 +99,7 @@ def match(word):
             # Use dictionaries and setdefault to match the characters in
             # the word to the ones in the pattern.
             wd, pd = {}, {}
-            # Return wether each character of word could be substituted
+            # Return whether each character of word could be substituted
             # with the corresponding character in pattern to give the
             # same result.
             return all(
diff --git a/leetcode/flip-string-to-monotone-increasing.py b/leetcode/flip-string-to-monotone-increasing.py
@@ -66,7 +66,7 @@ def minFlipsMonoIncr(self, s: str) -> int:
                 # We can append a 1 to the right at no extra cost.
                 ones += 1
             else:
-                # We need to decide wether it is better to flip this 0
+                # We need to decide whether it is better to flip this 0
                 # to a 1 or would have been better to flip all 1s in the
                 # prefix to a 0.
                 # res = min(ones, res + 1)
diff --git a/leetcode/insert-into-a-binary-search-tree.py b/leetcode/insert-into-a-binary-search-tree.py
@@ -0,0 +1,86 @@
+# 701. Insert into a Binary Search Tree
+# 🟠 Medium
+#
+# https://leetcode.com/problems/insert-into-a-binary-search-tree/
+#
+# Tags: Tree - Binary Search Tree - Binary Tree
+
+import timeit
+from typing import Optional
+
+from utils.binary_tree import BinaryTree, TreeNode
+
+
+# Travel through the tree choosing to go right or left based on node
+# values until we find the leave below which we will need to insert
+# the new node.
+#
+# Time Complexity: Best: O(log(n)) Worst: O(n) - We will travel the
+# entire height of the tree, ideally, it would be a well balanced tree
+# and its height would be log(n), but a skewed tree could have a height
+# of n, since we are not doing any balancing, after multiple inserts,
+# depending on the order in which the values were inserted, the tree
+# could become skewed.
+# Space complexity: Best: O(log(n)) Worst: O(n) - Each node that we
+# visit will add one call to the call stack, we could improve it to O(1)
+# using an iterative method because we only need to keep a pointer to
+# one node.
+#
+# Runtime 136 ms Beats 73.62%
+# Memory 16.9 MB Beats 90.27%
+class Solution:
+    def insertIntoBST(
+        self, root: Optional[TreeNode], val: int
+    ) -> Optional[TreeNode]:
+        node = TreeNode(val)
+        if not root:
+            return node
+
+        def ins(child, parent) -> None:
+            if child.val < parent.val:
+                if parent.left:
+                    ins(child, parent.left)
+                else:
+                    parent.left = child
+            else:
+                if parent.right:
+                    ins(child, parent.right)
+                else:
+                    parent.right = child
+
+        ins(node, root)
+        return root
+
+
+def test():
+    executors = [Solution]
+    tests = [
+        [[4, 2, 7, 1, 3], 5, [1, 2, 3, 4, 5, 7]],
+        [[40, 20, 60, 10, 30, 50, 70], 25, [10, 20, 25, 30, 40, 50, 60, 70]],
+        [
+            [4, 2, 7, 1, 3, None, None, None, None, None, None],
+            5,
+            [1, 2, 3, 4, 5, 7],
+        ],
+    ]
+    for executor in executors:
+        start = timeit.default_timer()
+        for _ in range(1):
+            for col, t in enumerate(tests):
+                sol = executor()
+                root = BinaryTree.fromList(t[0]).getRoot()
+                result_root = sol.insertIntoBST(root, t[1])
+                result = BinaryTree(result_root).inOrderTraverse()
+                exp = t[2]
+                assert result == exp, (
+                    f"\033[93m» {result} <> {exp}\033[91m for"
+                    + f" test {col} using \033[1m{executor.__name__}"
+                )
+        stop = timeit.default_timer()
+        used = str(round(stop - start, 5))
+        cols = "{0:20}{1:10}{2:10}"
+        res = cols.format(executor.__name__, used, "seconds")
+        print(f"\033[92m» {res}\033[0m")
+
+
+test()
diff --git a/leetcode/insert-into-a-binary-search-tree.rs b/leetcode/insert-into-a-binary-search-tree.rs
@@ -0,0 +1,133 @@
+// 701. Insert into a Binary Search Tree
+// 🟠 Medium
+//
+// https://leetcode.com/problems/insert-into-a-binary-search-tree/
+//
+// Tags: Tree - Binary Search Tree - Binary Tree
+
+use std::cell::RefCell;
+use std::rc::Rc;
+
+struct Solution;
+impl Solution {
+    // Travel through the tree choosing to go right or left based on node
+    // values until we find the leave below which we will need to insert
+    // the new node.
+    //
+    // Time Complexity: Best: O(log(n)) Worst: O(n) - We will travel the
+    // entire height of the tree, ideally, it would be a well balanced tree
+    // and its height would be log(n), but a skewed tree could have a height
+    // of n, since we are not doing any balancing, after multiple inserts,
+    // depending on the order in which the values were inserted, the tree
+    // could become skewed.
+    // Space complexity: O(1) - We only store a reference to the root and to
+    // the current node that we are visiting.
+    //
+    // Runtime 12 ms Beats 72.73%
+    // Memory 2.6 MB Beats 72.73%
+    pub fn insert_into_bst(
+        root: Option<Rc<RefCell<TreeNode>>>,
+        val: i32,
+    ) -> Option<Rc<RefCell<TreeNode>>> {
+        let new_node = TreeNode {
+            val,
+            left: None,
+            right: None,
+        };
+        if root.is_none() {
+            return Some(Rc::new(RefCell::new(new_node)));
+        }
+        let mut n = root.clone();
+        loop {
+            match n {
+                Some(node) => {
+                    if val < node.borrow().val {
+                        if node.borrow().left.is_some() {
+                            n = node.borrow().left.clone();
+                        } else {
+                            node.borrow_mut().left = Some(Rc::new(RefCell::new(new_node)));
+                            break;
+                        }
+                    } else {
+                        if node.borrow().right.is_some() {
+                            n = node.borrow().right.clone();
+                        } else {
+                            node.borrow_mut().right = Some(Rc::new(RefCell::new(new_node)));
+                            break;
+                        }
+                    }
+                }
+                None => panic!("This code should never run"),
+            }
+        }
+        root
+    }
+
+    // Travel through the tree choosing to go right or left based on node
+    // values until we find the leave below which we will need to insert
+    // the new node.
+    //
+    // Time Complexity: Best: O(log(n)) Worst: O(n) - We will travel the
+    // entire height of the tree, ideally, it would be a well balanced tree
+    // and its height would be log(n), but a skewed tree could have a height
+    // of n, since we are not doing any balancing, after multiple inserts,
+    // depending on the order in which the values were inserted, the tree
+    // could become skewed.
+    // Space complexity: Best: O(log(n)) Worst: O(n) - Each node that we
+    // visit will add one call to the call stack.
+    //
+    // Runtime 8 ms Beats 90.91%
+    // Memory 2.6 MB Beats 72.73%
+    pub fn insert_into_bst_rec(
+        root: Option<Rc<RefCell<TreeNode>>>,
+        val: i32,
+    ) -> Option<Rc<RefCell<TreeNode>>> {
+        // Always return a node reference, never None.
+        Some(match root {
+            // We are at the insertion point, create and return a new node.
+            None => Rc::new(RefCell::new(TreeNode {
+                val,
+                left: None,
+                right: None,
+            })),
+            // We are traveling down the tree decide whether to go right or left,
+            // create a new node with the result of calling insert_into_bst on the
+            // child and update the current child with that result.
+            Some(node_ref) => {
+                if val < node_ref.borrow().val {
+                    let node = Self::insert_into_bst(node_ref.borrow().left.clone(), val);
+                    node_ref.borrow_mut().left = node;
+                } else {
+                    let node = Self::insert_into_bst(node_ref.borrow().right.clone(), val);
+                    node_ref.borrow_mut().right = node;
+                }
+                node_ref
+            }
+        })
+    }
+}
+
+// Tests.
+fn main() {
+    // assert_eq!(Solution::min_diff_in_bst(root), 1);
+    println!("All tests passed!")
+}
+
+// Definition for a binary tree node.
+#[derive(Debug, PartialEq, Eq)]
+pub struct TreeNode {
+    pub val: i32,
+    pub left: Option<Rc<RefCell<TreeNode>>>,
+    pub right: Option<Rc<RefCell<TreeNode>>>,
+}
+
+impl TreeNode {
+    #[inline]
+    pub fn new(val: i32) -> Self {
+        TreeNode {
+            val,
+            left: None,
+            right: None,
+        }
+    }
+}
diff --git a/leetcode/maximum-profit-in-job-scheduling.py b/leetcode/maximum-profit-in-job-scheduling.py
@@ -112,7 +112,7 @@ def jobScheduling(
         jobs = sorted(zip(startTime, endTime, profit), key=itemgetter(1))
         # At time 0 we can make at most 0 profit.
         dp = [(0, 0)]
-        # Iterate over the jobs choosing wether to schedule them or skip
+        # Iterate over the jobs choosing whether to schedule them or skip
         # them based on how they would affect the maximum profit.
         for start, end, p in jobs:
             # If we decided to use this job, what would be the max
diff --git a/leetcode/palindromic-substrings.py b/leetcode/palindromic-substrings.py
@@ -34,8 +34,8 @@ def countSubstrings(self, s: str) -> int:
 
 # We can sacrifice memory to improve the results of the brute force
 # solution, if we start building palindromes of length 1, 2, 3... and
-# we store wether the string between two given indexes left-right is,
-# or is not, a palindrome, then we can check in O(1) wether the
+# we store whether the string between two given indexes left-right is,
+# or is not, a palindrome, then we can check in O(1) whether the
 # substring i:j is a palindrome by checking if the string i+1:j-1 is a
 # palindrome and s[i] == s[j].
 #
diff --git a/leetcode/range-sum-of-bst.py b/leetcode/range-sum-of-bst.py
@@ -13,7 +13,7 @@
 
 
 # We can use the value of the root node to determine which subtrees need
-# to be explored and wether the current node's value needs to be added.
+# to be explored and whether the current node's value needs to be added.
 # The recursive function calls itself, it could also have a nested
 # recursive function that performed the search, if we wanted to avoid
 # having to pass the low and high parameters in each call.
@@ -50,7 +50,7 @@ def rangeSumBST(
 
 
 # We can use the value of the root node to determine which subtrees need
-# to be explored and wether the current node's value needs to be added.
+# to be explored and whether the current node's value needs to be added.
 # The iterative version uses a stack to push subtrees that need to be
 # explored.
 #
diff --git a/leetcode/search-in-rotated-sorted-array.py b/leetcode/search-in-rotated-sorted-array.py
@@ -40,7 +40,7 @@ def search(self, nums: List[int], target: int) -> int:
                 else:
                     left = mid
             # The first element of the original array is to the right
-            # of left/right, check wether the target could be in the
+            # of left/right, check whether the target could be in the
             # head or the tail and set the boundaries for the binary
             # search.
             if target < nums[0]:
diff --git a/leetcode/utf-8-validation.py b/leetcode/utf-8-validation.py
@@ -21,7 +21,7 @@
 # Memory Usage: 14.1 MB, less than 96.64%
 class Solution:
     def validUtf8(self, data: List[int]) -> bool:
-        # Use a counter to determine wether we are processing a multi
+        # Use a counter to determine whether we are processing a multi
         # byte character.
         remaining_bytes = 0
         # Iterate over the input values checking if they form a valid

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`
`11`	`11`
`12`	`12`	`# The max profit each day depends on the max profit the previous day,`
`13`		`-# wether we are holding stock or not, and the number of transactions`
	`13`	`+# whether we are holding stock or not, and the number of transactions`
`14`	`14`	`# that we have left.`
`15`	`15`	`#`
`16`	`16`	`# Time complexity: O(k*n) - The outer loop iterates over n positions`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,8 @@`
`7`	`7`
`8`	`8`	`import timeit`
`9`	`9`
`10`		`-# Count the number of vowels in each half of the string, return wether`
	`10`	`+`
	`11`	`+# Count the number of vowels in each half of the string, return whether`
`11`	`12`	`# the count is the same.`
`12`	`13`	`#`
`13`	`14`	`# Time complexity: O(n) - We visit all elements in the input and perform`