# 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:

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
Recommended Articles
Page :