Solution 1 - Brute Force

Iterate through every pair of numbers using two nested loops. For each pair, check if they sum to the target. Return the indices when a match is found.

TimeComplexity: O(n^2)

SpaceComplexity: O(1)

""" 0001.1 - Solution 1 - Brute Force Approach """

#####################################################################################
# Imports
#####################################################################################
from typing import List

#####################################################################################
# Classes
#####################################################################################
class Solution:
    """Solution Class"""

    def twoSum(self, nums: List[int], target: int) -> List[int]:
        """Two Sum Function"""
        for i in range(len(nums)):
            for j in range(i + 1, len(nums)):
                if nums[i] + nums[j] == target:
                    return [i, j]


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().twoSum([3, 3], 6))
    print(Solution().twoSum([3, 2, 4], 6))
    print(Solution().twoSum([2, 7, 11, 15], 9))


#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
    testcase()

Solution 2 - Brute Force using `enumerate()`

Same brute force logic, but uses Python's enumerate() for cleaner index tracking instead of range(len(...)).

TimeComplexity: O(n^2)

SpaceComplexity: O(1)

""" 0001.1 - Solution 1 - Using Enumerate """

#####################################################################################
# Imports
#####################################################################################
from typing import List

#####################################################################################
# Classes
#####################################################################################
class Solution:
    """Solution Class"""

    def twoSum(self, nums: List[int], target: int) -> List[int]:
        """Two Sum Function"""
        for key1, num1 in enumerate(nums):
            for key2, num2 in enumerate(nums[key1 + 1 :], key1 + 1):
	              # enumerate(iterable, start=1) -> start value determines starting index
                # Printing value and key will output 1 i , 2 j, 3 k, 4 l 
                if num1 + num2 == target:
                    return [key1, key2]


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().twoSum([3, 3], 6))
    print(Solution().twoSum([3, 2, 4], 6))
    print(Solution().twoSum([2, 7, 11, 15], 9))


#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
    testcase()

Solution 1 - Inorder Traversal (Recursive)

Perform an inorder traversal of the BST, which visits nodes in sorted order. Track the previous node's value and compute the difference at each step, keeping the minimum.

TimeComplexity: O(n)

SpaceComplexity: O(n)

""" 0530.1 - Solution 1 - Recursive Inorder Traversal """

#####################################################################################
# Imports
#####################################################################################
from typing import Optional
import math

#####################################################################################
# Classes
#####################################################################################
class TreeNode:
    """TreeNode Class"""
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


class Solution:
    """Solution Class"""

    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        """Get Minimum Difference Function"""
        self.prev = None
        self.min_diff = math.inf

        def inorder(node: Optional[TreeNode]) -> None:
            if not node:
                return
            inorder(node.left)
            if self.prev is not None:
                self.min_diff = min(self.min_diff, node.val - self.prev)
            self.prev = node.val
            inorder(node.right)

        inorder(root)
        return self.min_diff


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    # Tree: [4, 2, 6, 1, 3]
    root = TreeNode(4, TreeNode(2, TreeNode(1), TreeNode(3)), TreeNode(6))
    print(Solution().getMinimumDifference(root))  # Output: 1

    # Tree: [1, 0, 48, None, None, 12, 49]
    root2 = TreeNode(1, TreeNode(0), TreeNode(48, TreeNode(12), TreeNode(49)))
    print(Solution().getMinimumDifference(root2))  # Output: 1


#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
    testcase()

Solution 2 - Inorder Traversal (Iterative)

Same inorder approach but using an explicit stack instead of recursion. This avoids potential stack overflow for very deep trees.

TimeComplexity: O(n)

SpaceComplexity: O(n)

""" 0530.2 - Solution 2 - Iterative Inorder Traversal """

#####################################################################################
# Imports
#####################################################################################
from typing import Optional
import math

#####################################################################################
# Classes
#####################################################################################
class TreeNode:
    """TreeNode Class"""
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


class Solution:
    """Solution Class"""

    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        """Get Minimum Difference Function"""
        stack = []
        prev = None
        min_diff = math.inf
        curr = root

        while curr or stack:
            while curr:
                stack.append(curr)
                curr = curr.left
            curr = stack.pop()
            if prev is not None:
                min_diff = min(min_diff, curr.val - prev)
            prev = curr.val
            curr = curr.right

        return min_diff


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    # Tree: [4, 2, 6, 1, 3]
    root = TreeNode(4, TreeNode(2, TreeNode(1), TreeNode(3)), TreeNode(6))
    print(Solution().getMinimumDifference(root))  # Output: 1

    # Tree: [1, 0, 48, None, None, 12, 49]
    root2 = TreeNode(1, TreeNode(0), TreeNode(48, TreeNode(12), TreeNode(49)))
    print(Solution().getMinimumDifference(root2))  # Output: 1


#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
    testcase()

Solution 3 - Inorder to Sorted List

Collect all node values via inorder traversal into a sorted list, then iterate through adjacent pairs to find the minimum difference.

TimeComplexity: O(n)

SpaceComplexity: O(n)

""" 0530.3 - Solution 3 - Inorder to Sorted List """

#####################################################################################
# Imports
#####################################################################################
from typing import Optional, List
import math

#####################################################################################
# Classes
#####################################################################################
class TreeNode:
    """TreeNode Class"""
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


class Solution:
    """Solution Class"""

    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        """Get Minimum Difference Function"""
        values: List[int] = []

        def inorder(node: Optional[TreeNode]) -> None:
            if not node:
                return
            inorder(node.left)
            values.append(node.val)
            inorder(node.right)

        inorder(root)

        min_diff = math.inf
        for i in range(1, len(values)):
            min_diff = min(min_diff, values[i] - values[i - 1])

        return min_diff


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    # Tree: [4, 2, 6, 1, 3]
    root = TreeNode(4, TreeNode(2, TreeNode(1), TreeNode(3)), TreeNode(6))
    print(Solution().getMinimumDifference(root))  # Output: 1

    # Tree: [1, 0, 48, None, None, 12, 49]
    root2 = TreeNode(1, TreeNode(0), TreeNode(48, TreeNode(12), TreeNode(49)))
    print(Solution().getMinimumDifference(root2))  # Output: 1


#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
    testcase()

0530 - Minimum Absolute Difference in BST

Solution 1 - Brute Force

Solution 2 - Brute Force using enumerate()

Solution 1 - Inorder Traversal (Recursive)

Solution 2 - Inorder Traversal (Iterative)

Solution 3 - Inorder to Sorted List

Solution 2 - Brute Force using `enumerate()`