All Nodes at Distance K Python Solution

In this tutorial, we will solve a problem on Binary Tree data structure. The problem statement is that if we are provided with the root node of the binary tree, the target node, and the distance value k, we need to return the list of all the values present at distance k from the target node in the given binary tree.

Consider the tree:

                      1
                     / \
                   /     \
                /          \
             2              3
          /    \          /    \
       4         5     6       7
                 / \
                8   9

Look at the tree diagram above

Input: target = Node object with value 2.

root = Node object pointing to 1.

k = 2.

Output: [8, 9, 3]

If the target node is 4 and k is equal to 4, then the output

will be [6, 7]

Approach - 1

The main trick in this question is that we have to do more than traverse from top to bottom. We need two kinds of pointers. These are:

The first type of pointer is the one which will point toward the child nodes of the target node. For instance, if our target node is 2 and the value of k is 2, then the child nodes are 4 and 5.
The second pointer is the one that will point toward the parent node of the target node. For example, if the target node is 2, this pointer will point toward the parent node, 1.

The first pointer is the regular pointer present in the structure of the binary tree. However, the second kind of pointer is not available to us. Hence, we need to create this pointer.

Once we get both pointers, we must traverse the nodes starting from the target nodes. We will traverse in the radially outward direction from the target node, and on the completion of each traversal, we will decrement k by 1.

But the main question is how to get the nodes attached to the parent node of the target node. We have to traverse through the nodes that are not a part of the subtrees of the target node. For every node present in the upper tree, we will find the distance of that node from the target node, let this distance be dist, and now we will traverse through the other subtree of the nodes present in the upper tree and store all the nodes present at k - dist distance from the ancestor node.

Below is the code of the above approach:

Code

# Python program to get the nodes present at the k distance from the target node

# Creating a constructor class for the node
class Node:
 # Defining the method to create a new node
 def __init__(self, val):
  self.val = val
  self.left = None
  self.right = None
   
# Defining the recursive function that will print the nodes k-distanced from the given node
# We will pass the root node to this function, and the distance k
# This will traverse the binary tree in the downward direction
def kDistanceNodeDown(root, k):
   
  # Base Case
  if root is None or k< 0 :
    return
   
  # If we have reached the distance k, print the value of the node
  if k == 0 :
    print (root.val)
    return
   
  # Calling the function recursively for the left and right subtrees of the given root node
  kDistanceNodeDown(root.left, k - 1)
  kDistanceNodeDown(root.right, k - 1)

# Creating a function that will print all the nodes at k-distance from the target node
# The required node can we present in the upward or the downward tree of the target node
# This function will return the distance of the root from the target node, and it will return -1 if the target node is not found in the tree of the given root node.
def kDistanceNode(root, target, k):
   
  # Base Case: If the given tree is empty, return -1
  if root is None:
    return -1

  # If the target node is the same as the root node, we will use the downward traversal function
  # which will print all the nodes present at k distance in the right and left sub-trees of the binary tree with the given root node.
  if root == target:
    kDistanceNodeDown(root, k)
    return 0
   
  # Calling the function recursively to traverse the left subtree
  lt = kDistanceNode(root.left, target, k)
   
  # Checking if the target node is present in the left subtree or not
  if lt != -1:
     
    # If the root node is present at a distance k from the target node,
    # The function will print the root node value
    # lt is the distance from the left child of the root node to the target
    if lt + 1 == k :
      print (root.val)
   
    # Otherwise, we will go to the right subtree and print the nodes present at k - lt - 2 distance
    # We are subtracting 2 because the right child is always 2 edges away from the left child
    else:
      kDistanceNodeDown(root.right, k - lt - 2)

    # Incrementing the distance by 1 and returning the value for parent nodes
    return 1 + lt

  # We will repeat the steps for the right subtree
  # This part will be executed only if we cannot find the target node in the left subtree
  rt = kDistanceNode(root.right, target, k)
  # Checking if the node is present in the right subtree
  if rt != -1:
    # Checking if the root node is present at k distance from the target node
    if (rt + 1 == k):
      print (root.data)
    # Traversing the left subtree
    else:
      kDistanceNodeDown(root.left, k - rt - 2)
    return 1 + rt

  # If the target node was not present in both right and left subtrees, that means the node is not present in the tree
  return -1

# Driver program
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
root.left.right.left = Node(6)
root.left.right.right = Node(7)
root.left.right.left = Node(8)
root.left.right.right = Node(9)
target = root.left.right
kDistanceNode(root, target, 2)

Output:

4
1
2

Time Complexity: This algorithm has the worst-case time complexity of O(N). The time complexity is not more than linear because no node in this algorithm is traversed more than once.

Space Complexity: This program has O(h) space complexity. Here h is the height of the given binary tree.

Approach - 2

This approach is more straightforward than the previous approach.

We will first traverse the complete binary tree and get the path of the nodes from the root node. We will store this path in a list.
In the next step, we will iterate through the list, and for every ith element of the path list, we will iterate and print the nodes present at the (k - i)th distance.

Code

# Python program to find the nodes at distance k

# Creating a constructor class for the node
class Node:
 # Defining the method to create a new node
 def __init__(self, val):
  self.val = val
  self.left = None
  self.right = None

class Distance:
    node_path = None

    # Defining the main function to perform all the steps
    def distK(self, root, target, K):
        self.node_path = []

        # Finding path of the nodes
        self.Path(root, target)
        res = []
        for i in range(len(self.node_path)):
            self.findKDistance(self.node_path[i], K - i, res, None if i == 0 else self.node_path[i - 1])
        return res
    
    # Defining a function to find the nodes at distance k from the given node
    def findKDistance(self, node, distance, res, cond):

        # Specifying the base condition
        if distance < 0 or node is None or (cond and node == cond):
            return
        if distance == 0:
            res.append(node.val)
        self.findKDistance(node.left, distance - 1, res, cond)
        self.findKDistance(node.right, distance - 1, res, cond)

    # Defining the function that will find the path pf the nodes
    def Path(self, node, t):

        # Specifying the base condition
        if node is None:
            return False

        # Recursively calling the function for the left and right subtrees
        if node == t or self.Path(node.left, t) or self.Path(node.right, t):
            self.node_path.append(node)
            return True
        return False

# Driver program
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
root.left.right.left = Node(6)
root.left.right.right = Node(7)
root.left.right.left = Node(8)
root.left.right.right = Node(9)
target = root.left.right
d = Distance()
print(d.distK(root, target, 2))

Output: