Find distance between two nodes of a Binary Search Tree

Introduction to Binary Search Trees (BSTs)

A hierarchical data structure called a binary search tree is employed for effective data storage and retrieval. It is made up of nodes and edges, where each node houses a value.

Anatomy of a Binary Search Tree

A BST consists of nodes with three components:

Value: The data stored in the node.
Left Child: A reference to the left subtree, which contains nodes with values less than the current node.
Right Child: A reference to the right subtree, which contains nodes with values greater than the current node.

What is Node Distance?

In the context of a BST, node distance is the quantity of edges separating two nodes. It measures the "relatedness" or "closeness" between two nodes in the tree.

Understanding Binary Search Trees (BSTs)

Before embarking on the journey of calculating the distance between two nodes in a Binary Search Tree, it is essential to revisit the core concepts of BSTs. A Binary Search Tree is a hierarchical data structure wherein each node possesses, at most, two children: a left child and a right child.

The Quest for Distance: Algorithm Overview

Step 1: Identifying the Lowest Common Ancestor (LCA)

Finding the two target nodes' Lowest Common Ancestor (LCA) is the first and most important step in this journey. By moving up the tree through parent pointers, the LCA is the node from which both target nodes can be reached. To achieve this, we start a traversal of the tree from the root and move progressively downward. The algorithm compares the values of the current node and the target nodes at each step. The traversal continues up until a node is discovered whose value is halfway between the values of the two target nodes. This node is the LCA.

Step 2: Calculating Distances

The distances between the LCA and each of the target nodes must then be calculated after the LCA has been located. A depth-first search (DFS) that starts from the LCA and travels to each target node separately is used to achieve this. The algorithm counts the edges it comes across while moving through the tree, effectively calculating the distance from the LCA to each target node.

Step 3: Summing Up the Distances

The final step in our quest is to combine the distances calculated in Step 2. Adding these distances together provides us with the total distance between the two target nodes. This distance signifies the number of edges one must traverse to move from one target node to the other within the Binary Search Tree.

Calculating Node Distance in a Binary Search Tree

Understanding Recursive Algorithms

In computer science, recursive algorithms are a useful tool. They divide a problem into more manageable, more compact subproblems. We can use recursion to iterate through the tree and locate the LCA in the case of calculating node distance.

Implementing the Distance Calculation Function

Let's implement a function that calculates the node distance between two nodes in a BST. We'll use a recursive approach to find the LCA and sum the distances.

Code:

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

def find_distance(root, node1, node2):
    def find_path_to_node(root, node, path):
        if root is None:
            return False
        path.append(root)
        if root.value == node:
            return True
        if (root.left and find_path_to_node(root.left, node, path)) or (root.right and find_path_to_node(root.right, node, path)):
            return True
        path.pop()
        return False

    path1 = []
    path2 = []

    if not find_path_to_node(root, node1, path1) or not find_path_to_node(root, node2, path2):
        return -1

    i = 0
    while i < len(path1) and i < len(path2) and path1[i].value == path2[i].value:
        i += 1

    distance = (len(path1) - i) + (len(path2) - i)
    return distance

# Example usage:
# Creating a Binary Search Tree
root = TreeNode(5)
root.left = TreeNode(2)
root.right = TreeNode(8)
root.left.left = TreeNode(1)
root.left.right = TreeNode(4)
root.right.left = TreeNode(6)
root.right.right = TreeNode(9)

# Finding the distance between nodes 1 and 9
distance = find_distance(root, 1, 9)
print("Distance between nodes 1 and 9:", distance)

Output:

Distance between nodes 1 and 9: 4

Handling Edge Cases

It's essential to consider edge cases when implementing the distance calculation function. For instance, what happens if one of the nodes doesn't exist in the tree?