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

• Difficulty Level : Expert
• Last Updated : 13 Sep, 2021

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:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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 ``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;``    ``}` `    ``// Recurr 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``;``    ``}` `    ``// Recurr 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` `    ``# Recurr 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;``    ``}` `    ``// Recurr 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

 ``
Output:
`11`

Time Complexity:
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up