 Open in App
Not now

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

• Difficulty Level : Medium
• Last Updated : 31 Jan, 2023

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

 ``

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.

My Personal Notes arrow_drop_up