Sum of all nodes with smaller values at a distance K from a given node in a BST

Given a Binary Search Tree, a target node in the BST, and an integer value K, the task is to find the sum of all nodes that are at a distance K from the target node whose value is less than the target node.

Examples:

Input: target = 7, K = 2

Output: 11
Explanation:
The nodes at a  distance K(= 2) from the node 7 is 1, 4, and 6. Therefore, the sum of nodes is 11.

Input: target = 5, K = 1

Output: 4

Approach: The given problem can be solved by performing DFS Traversal for K distance below the target node and perform the DFS Traversal upward K distance from the target node. Follow the steps below to solve the problem:

• Define a function kDistanceDownSum(root, k, &sum) and perform the following steps:
  • For the Base Case, check if the root is nullptr and k is less than 0, then return from the function.
  • If the value of k equals 0, then add root->val to the variable sum and return.
  • Call the same function kDistanceDownSum(root->left, k-1, sum) and kDistanceDownSum(root->right, k – 1, sum) for the left and right sub-trees.
• For the Base Case, check if the root is nullptr, then return -1.
• If the root is the same as the target, then call the function kDistanceDownSum(root->left, k – 1, sum) to calculate the sum for the first type of nodes and return 0(No second type of nodes possible).
• Initialize the variable dl as -1 and if the target is less than root, then set the value of dl as the value returned by the function kDistanceSum(root->left, target k, sum).
• If the value of dl is not equal to -1, then if sum equals (dl + 1), then add the value of root->data to the sum and then return -1.
• Similarly, initialize the variable dr as -1 and if the target is greater than the root, then update the value of dr to the value returned by kDistanceSum(root->right, target k, sum).
• If the value of dr is not equal to -1, then if the value of sum equals (dr + 1), then add the value of root->data to the sum. Otherwise, call the function kDistanceDownSum(root->left, k – dr – 2, sum) and return (1 + dr).
• After performing the above steps, print the value of ans as the resultant sum.

Following is the implementation of the above approach:

C++

// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

// Structure of Tree
struct TreeNode {

    int data;
    TreeNode* left;
    TreeNode* right;

    // Constructor
    TreeNode(int data)
    {
        this->data = data;
        this->left = NULL;
        this->right = NULL;
    }
};

// Function to add the node to the sum
// below the target node
void kDistanceDownSum(TreeNode* root,
                      int k, int& sum)
{

    // Base Case
    if (root == NULL || k < 0)
        return;

    // If Kth distant node is reached
    if (k == 0) {
        sum += root->data;
        return;
    }

    // Recur for the left and the
    // right subtrees
    kDistanceDownSum(root->left,
                     k - 1, sum);
    kDistanceDownSum(root->right,
                     k - 1, sum);
}

// Function to find the K distant nodes
// from target node, it returns -1 if
// target node is not present in tree
int kDistanceSum(TreeNode* root,
                 int target,
                 int k, int& sum)
{
    // Base Case 1
    if (root == NULL)
        return -1;

    // If target is same as root.
    if (root->data == target) {
        kDistanceDownSum(root->left,
                         k - 1, sum);
        return 0;
    }

    // Recur for the left subtree
    int dl = -1;

    // Tree is BST so reduce the
    // search space
    if (target < root->data) {
        dl = kDistanceSum(root->left,
                          target, k, sum);
    }

    // Check if target node was found
    // in left subtree
    if (dl != -1) {

        // If root is at distance k from
        // the target
        if (dl + 1 == k)
            sum += root->data;

        // Node less than target will be
        // present in left
        return -1;
    }

    // When node is not present in the
    // left subtree
    int dr = -1;
    if (target > root->data) {
        dr = kDistanceSum(root->right,
                          target, k, sum);
    }

    if (dr != -1) {

        // If Kth distant node is reached
        if (dr + 1 == k)
            sum += root->data;

        // Node less than target at k
        // distance maybe present in the
        // left tree
        else
            kDistanceDownSum(root->left,
                             k - dr - 2, sum);

        return 1 + dr;
    }

    // If target was not present in the
    // left nor in right subtree
    return -1;
}

// Function to insert a node in BST
TreeNode* insertNode(int data,
                     TreeNode* root)
{
    // If root is NULL
    if (root == NULL) {
        TreeNode* node = new TreeNode(data);
        return node;
    }

    // Insert the data in right half
    else if (data > root->data) {
        root->right = insertNode(
            data, root->right);
    }

    // Insert the data in left half
    else if (data <= root->data) {
        root->left = insertNode(
            data, root->left);
    }

    // Return the root node
    return root;
}

// Function to find the sum of K distant
// nodes from the target node having
// value less than target node
void findSum(TreeNode* root, int target,
             int K)
{

    // Stores the sum of nodes having
    // values < target at K distance
    int sum = 0;

    kDistanceSum(root, target, K, sum);

    // Print the resultant sum
    cout << sum;
}

// Driver Code
int main()
{
    TreeNode* root = NULL;
    int N = 11;
    int tree[] = { 3, 1, 7, 0, 2, 5,
                   10, 4, 6, 9, 8 };

    // Create the Tree
    for (int i = 0; i < N; i++) {
        root = insertNode(tree[i], root);
    }

    int target = 7;
    int K = 2;
    findSum(root, target, K);

    return 0;
}

Java

// Java program for the above approach
import java.util.*;

public class GFG{
    static int sum;

// Structure of Tree
static class TreeNode {

    int data;
    TreeNode left;
    TreeNode right;

    // Constructor
    TreeNode(int data)
    {
        this.data = data;
        this.left = null;
        this.right = null;
    }
};

// Function to add the node to the sum
// below the target node
static void kDistanceDownSum(TreeNode root,
                      int k)
{

    // Base Case
    if (root == null || k < 0)
        return;

    // If Kth distant node is reached
    if (k == 0) {
        sum += root.data;
        return;
    }

    // Recur for the left and the
    // right subtrees
    kDistanceDownSum(root.left,
                     k - 1);
    kDistanceDownSum(root.right,
                     k - 1);
}

// Function to find the K distant nodes
// from target node, it returns -1 if
// target node is not present in tree
static int kDistanceSum(TreeNode root,
                 int target,
                 int k)
{
    // Base Case 1
    if (root == null)
        return -1;

    // If target is same as root.
    if (root.data == target) {
        kDistanceDownSum(root.left,
                         k - 1);
    return 0;
    }

    // Recur for the left subtree
    int dl = -1;

    // Tree is BST so reduce the
    // search space
    if (target < root.data) {
        dl = kDistanceSum(root.left,
                          target, k);
    }

    // Check if target node was found
    // in left subtree
    if (dl != -1) {

        // If root is at distance k from
        // the target
        if (dl + 1 == k)
            sum += root.data;

        // Node less than target will be
        // present in left
        return -1;
    }

    // When node is not present in the
    // left subtree
    int dr = -1;
    if (target > root.data) {
        dr = kDistanceSum(root.right,
                          target, k);
    }

    if (dr != -1) {

        // If Kth distant node is reached
        if (dr + 1 == k)
            sum += root.data;

        // Node less than target at k
        // distance maybe present in the
        // left tree
        else
            kDistanceDownSum(root.left,
                             k - dr - 2);

        return 1 + dr;
    }

    // If target was not present in the
    // left nor in right subtree
    return -1;
}

// Function to insert a node in BST
static TreeNode insertNode(int data,
                     TreeNode root)
{
    // If root is null
    if (root == null) {
        TreeNode node = new TreeNode(data);
        return node;
    }

    // Insert the data in right half
    else if (data > root.data) {
        root.right = insertNode(
            data, root.right);
    }

    // Insert the data in left half
    else if (data <= root.data) {
        root.left = insertNode(
            data, root.left);
    }

    // Return the root node
    return root;
}

// Function to find the sum of K distant
// nodes from the target node having
// value less than target node
static void findSum(TreeNode root, int target,
             int K)
{

    // Stores the sum of nodes having
    // values < target at K distance
    sum = 0;

    kDistanceSum(root, target, K);

    // Print the resultant sum
    System.out.print(sum);
}

// Driver Code
public static void main(String[] args)
{
    TreeNode root = null;
    int N = 11;
    int tree[] = { 3, 1, 7, 0, 2, 5,
                   10, 4, 6, 9, 8 };

    // Create the Tree
    for (int i = 0; i < N; i++) {
        root = insertNode(tree[i], root);
    }

    int target = 7;
    int K = 2;
    findSum(root, target, K);

}
}

// This code is contributed by 29AjayKumar

Python3

# python 3 program for the above approach

# Structure of Tree
sum = 0

class Node:
    # A constructor to create a new node
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

# Function to add the node to the sum
# below the target node
def kDistanceDownSum(root, k):
    global sum
    # Base Case
    if (root == None or k < 0):
        return

    # If Kth distant node is reached
    if (k == 0):
        sum += root.data
        return

    # Recur for the left and the
    # right subtrees
    kDistanceDownSum(root.left,k - 1)
    kDistanceDownSum(root.right,k - 1)

# Function to find the K distant nodes
# from target node, it returns -1 if
# target node is not present in tree
def kDistanceSum(root, target, k):
    global sum
    # Base Case 1
    if (root == None):
        return -1

    # If target is same as root.
    if (root.data == target):
        kDistanceDownSum(root.left,k - 1)
        return 0

    # Recur for the left subtree
    dl = -1

    # Tree is BST so reduce the
    # search space
    if (target < root.data):
        dl = kDistanceSum(root.left, target, k)

    # Check if target node was found
    # in left subtree
    if (dl != -1):
        # If root is at distance k from
        # the target
        if (dl + 1 == k):
            sum += root.data

        # Node less than target will be
        # present in left
        return -1

    # When node is not present in the
    # left subtree
    dr = -1
    if (target > root.data):
        dr = kDistanceSum(root.right, target, k)

    if (dr != -1):
        # If Kth distant node is reached
        if (dr + 1 == k):
            sum += root.data

        # Node less than target at k
        # distance maybe present in the
        # left tree
        else:
            kDistanceDownSum(root.left, k - dr - 2)

        return 1 + dr

    # If target was not present in the
    # left nor in right subtree
    return -1

# Function to insert a node in BST
def insertNode(data, root):
    # If root is NULL
    if (root == None):
        node = Node(data)
        return node

    # Insert the data in right half
    elif (data > root.data):
        root.right = insertNode(data, root.right)

    # Insert the data in left half
    elif(data <= root.data):
        root.left = insertNode(data, root.left)

    # Return the root node
    return root

# Function to find the sum of K distant
# nodes from the target node having
# value less than target node
def findSum(root, target, K):

    # Stores the sum of nodes having
    # values < target at K distance
    kDistanceSum(root, target, K)

    # Print the resultant sum
    print(sum)

# Driver Code
if __name__ == '__main__':
    root = None
    N = 11
    tree = [3, 1, 7, 0, 2, 5,10, 4, 6, 9, 8]

    # Create the Tree
    for i in range(N):
        root = insertNode(tree[i], root)

    target = 7
    K = 2
    findSum(root, target, K)

    # This code is contributed by SURENDRA_GANGWAR.

C#

// C# program for the above approach
using System;

public class GFG{
    static int sum;

// Structure of Tree
public

 class TreeNode {

    public

 int data;
    public

 TreeNode left;
    public

 TreeNode right;

    // Constructor
    public TreeNode(int data)
    {
        this.data = data;
        this.left = null;
        this.right = null;
    }
};

// Function to add the node to the sum
// below the target node
static void kDistanceDownSum(TreeNode root,
                      int k)
{

    // Base Case
    if (root == null || k < 0)
        return;

    // If Kth distant node is reached
    if (k == 0) {
        sum += root.data;
        return;
    }

    // Recur for the left and the
    // right subtrees
    kDistanceDownSum(root.left,
                     k - 1);
    kDistanceDownSum(root.right,
                     k - 1);
}

// Function to find the K distant nodes
// from target node, it returns -1 if
// target node is not present in tree
static int kDistanceSum(TreeNode root,
                 int target,
                 int k)
{
    // Base Case 1
    if (root == null)
        return -1;

    // If target is same as root.
    if (root.data == target) {
        kDistanceDownSum(root.left,
                         k - 1);
    return 0;
    }

    // Recur for the left subtree
    int dl = -1;

    // Tree is BST so reduce the
    // search space
    if (target < root.data) {
        dl = kDistanceSum(root.left,
                          target, k);
    }

    // Check if target node was found
    // in left subtree
    if (dl != -1) {

        // If root is at distance k from
        // the target
        if (dl + 1 == k)
            sum += root.data;

        // Node less than target will be
        // present in left
        return -1;
    }

    // When node is not present in the
    // left subtree
    int dr = -1;
    if (target > root.data) {
        dr = kDistanceSum(root.right,
                          target, k);
    }

    if (dr != -1) {

        // If Kth distant node is reached
        if (dr + 1 == k)
            sum += root.data;

        // Node less than target at k
        // distance maybe present in the
        // left tree
        else
            kDistanceDownSum(root.left,
                             k - dr - 2);

        return 1 + dr;
    }

    // If target was not present in the
    // left nor in right subtree
    return -1;
}

// Function to insert a node in BST
static TreeNode insertNode(int data,
                     TreeNode root)
{
    // If root is null
    if (root == null) {
        TreeNode node = new TreeNode(data);
        return node;
    }

    // Insert the data in right half
    else if (data > root.data) {
        root.right = insertNode(
            data, root.right);
    }

    // Insert the data in left half
    else if (data <= root.data) {
        root.left = insertNode(
            data, root.left);
    }

    // Return the root node
    return root;
}

// Function to find the sum of K distant
// nodes from the target node having
// value less than target node
static void findSum(TreeNode root, int target,
             int K)
{

    // Stores the sum of nodes having
    // values < target at K distance
    sum = 0;

    kDistanceSum(root, target, K);

    // Print the resultant sum
    Console.Write(sum);
}

// Driver Code
public static void Main(String[] args)
{
    TreeNode root = null;
    int N = 11;
    int []tree = { 3, 1, 7, 0, 2, 5,
                   10, 4, 6, 9, 8 };

    // Create the Tree
    for (int i = 0; i < N; i++) {
        root = insertNode(tree[i], root);
    }

    int target = 7;
    int K = 2;
    findSum(root, target, K);

}
}

// This code is contributed by gauravrajput1

Javascript

<script>
// Javascript program for the above approach

// Structure of Tree
let sum = 0;

class TreeNode {
  // Constructor
  constructor(data = "", left = null, right = null) {
    this.data = data;
    this.left = left;
    this.right = right;
  }
}

// Function to add the node to the sum
// below the target node
function kDistanceDownSum(root, k)
{
  // Base Case
  if (root == null || k < 0) {
    return
  }

  // If Kth distant node is reached
  if (k == 0) {
    sum += root.data;
    return;
  }

  // Recur for the left and the
  // right subtrees
  kDistanceDownSum(root.left, k - 1);
  kDistanceDownSum(root.right, k - 1);
}

// Function to find the K distant nodes
// from target node, it returns -1 if
// target node is not present in tree
function kDistanceSum(root, target, k) {
  // Base Case 1
  if (root == null) return -1;

  // If target is same as root.
  if (root.data == target) {
    kDistanceDownSum(root.left, k - 1);
    return 0;
  }

  // Recur for the left subtree
  let dl = -1;

  // Tree is BST so reduce the
  // search space
  if (target < root.data) {
    dl = kDistanceSum(root.left, target, k);
  }

  // Check if target node was found
  // in left subtree
  if (dl != -1) {
    // If root is at distance k from
    // the target
    if (dl + 1 == k) sum += root.data;

    // Node less than target will be
    // present in left
    return -1;
  }

  // When node is not present in the
  // left subtree
  let dr = -1;
  if (target > root.data) {
    dr = kDistanceSum(root.right, target, k);
  }

  if (dr != -1) {
    // If Kth distant node is reached
    if (dr + 1 == k) sum += root.data;
    // Node less than target at k
    // distance maybe present in the
    // left tree
    else kDistanceDownSum(root.left, k - dr - 2);

    return 1 + dr;
  }

  // If target was not present in the
  // left nor in right subtree
  return -1;
}

// Function to insert a node in BST
function insertNode(data, root) {
  // If root is null
  if (root == null) {
    let node = new TreeNode(data);
    return node;
  }

  // Insert the data in right half
  else if (data > root.data) {
    root.right = insertNode(data, root.right);
  }

  // Insert the data in left half
  else if (data <= root.data) {
    root.left = insertNode(data, root.left);
  }

  // Return the root node
  return root;
}

// Function to find the sum of K distant
// nodes from the target node having
// value less than target node
function findSum(root, target, K) {
  // Stores the sum of nodes having
  // values < target at K distance
  kDistanceSum(root, target, K, sum);

  // Print the resultant sum
  document.write(sum);
}

// Driver Code

let root = null;
let N = 11;
let tree = [3, 1, 7, 0, 2, 5, 10, 4, 6, 9, 8];

// Create the Tree
for (let i = 0; i < N; i++) {
  root = insertNode(tree[i], root);
}

let target = 7;
let K = 2;
findSum(root, target, K);
</script>

Output:

11

Time Complexity: O(N) where N is the number of nodes in given binary tree.
Auxiliary Space: O(h) where h is the height of binary tree due to recursion call stack.