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++ 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 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 |
# 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# 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 |
<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> |
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.
Approach using BFS:-
- We will be using level order traversal to find the sum of smaller value nodes
Implementation:-
- First we will find the target node using level order traversal.
- While finding the target node we will store the parent of each node so that we can move towards the parent of the node as well.
- After this we will traverse from the target node to all the tree directions that is toward both child and parent till distance K and add the values of node into our answer which are smaller than target at distance K.
// 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 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)
{ //variable to store answer
int ans = 0;
//queue for bfs
queue<TreeNode*> q;
q.push(root);
//to store target node
TreeNode* need;
//map to store parent of each node
unordered_map<TreeNode*, TreeNode*> m;
//bfs
while (q.size()){
int s = q.size();
//traversing to current level
for ( int i=0;i<s;i++){
TreeNode* temp = q.front();
q.pop();
//if target value found
if (temp->data==target) need=temp;
if (temp->left){
q.push(temp->left);
m[temp->left]=temp;
}
if (temp->right){
q.push(temp->right);
m[temp->right]=temp;
}
}
}
//map to store occurrence of a node
//that is the node has taken or not
unordered_map<TreeNode*, int > mm;
q.push(need);
//to store current distance
int c = 0;
while (q.size()){
int s = q.size();
for ( int i=0;i<s;i++){
TreeNode* temp = q.front();
q.pop();
mm[temp] = 1;
if (temp->data<target and c==K)
ans+=temp->data;
//moving left
if (temp->left&&mm[temp->left]==0){
q.push(temp->left);
}
//moving right
if (temp->right&&mm[temp->right]==0){
q.push(temp->right);
}
//movinf to parent
if (m[temp]&&mm[m[temp]]==0){
q.push(m[temp]);
}
}
c++;
if (c>K) break ;
}
cout<<ans<<endl;
} // 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;
} //code contributed by shubhamrajput6156 |
import java.util.*;
// Structure of Tree class TreeNode {
int data;
TreeNode left;
TreeNode right;
// Constructor
TreeNode( int data)
{
this .data = data;
this .left = null ;
this .right = null ;
}
} public class Main {
// Function to insert a node in BST
public 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
public static void findSum(TreeNode root, int target,
int K)
{
// variable to store answer
int ans = 0 ;
// queue for bfs
Queue<TreeNode> q = new LinkedList<>();
q.add(root);
// to store target node
TreeNode need = null ;
// map to store parent of each node
HashMap<TreeNode, TreeNode> m = new HashMap<>();
// bfs
while (!q.isEmpty()) {
int s = q.size();
// traversing to current level
for ( int i = 0 ; i < s; i++) {
TreeNode temp = q.peek();
q.remove();
// if target value found
if (temp.data == target)
need = temp;
if (temp.left != null ) {
q.add(temp.left);
m.put(temp.left, temp);
}
if (temp.right != null ) {
q.add(temp.right);
m.put(temp.right, temp);
}
}
}
// map to store occurrence of a node
// that is the node has taken or not
HashMap<TreeNode, Integer> mm = new HashMap<>();
q.add(need);
// to store current distance
int c = 0 ;
while (!q.isEmpty()) {
int s = q.size();
for ( int i = 0 ; i < s; i++) {
TreeNode temp = q.peek();
q.remove();
mm.put(temp, 1 );
if (temp.data < target && c == K)
ans += temp.data;
// moving left
if (temp.left != null && mm.getOrDefault(temp.left, 0 ) == 0 ) {
q.add(temp.left);
}
// moving right
if (temp.right != null && mm.getOrDefault(temp.right, 0 ) == 0 ) {
q.add(temp.right);
}
// moving to parent
if (m.get(temp) != null && mm.getOrDefault(m.get(temp), 0 ) == 0 ) {
q.add(m.get(temp));
}
}
c++;
if (c > K)
break ;
}
System.out.println(ans);
}
// 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);
}
} |
from collections import deque
# Structure of Tree class TreeNode:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
# Function to insert a node in BST def insertNode(data, root):
# If root is None
if root is None :
return TreeNode(data)
# Insert the data in the right half
if data > root.data:
root.right = insertNode(data, root.right)
# Insert the data in the left half
else :
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):
# Variable to store the answer
ans = 0
# Queue for BFS
q = deque()
q.append(root)
# To store the target node
need = None
# Dictionary to store parent of each node
m = {}
# BFS
while q:
s = len (q)
# Traverse the current level
for i in range (s):
temp = q.popleft()
# If the target value is found
if temp.data = = target:
need = temp
if temp.left:
q.append(temp.left)
m[temp.left] = temp
if temp.right:
q.append(temp.right)
m[temp.right] = temp
# Dictionary to store the occurrence of a node
# that is whether the node has been visited or not
mm = {}
q.append(need)
# To store the current distance
c = 0
while q:
s = len (q)
for i in range (s):
temp = q.popleft()
mm[temp] = 1
if temp.data < target and c = = K:
ans + = temp.data
# Moving left
if temp.left and mm.get(temp.left, 0 ) = = 0 :
q.append(temp.left)
# Moving right
if temp.right and mm.get(temp.right, 0 ) = = 0 :
q.append(temp.right)
# Moving to parent
if temp in m and mm.get(m[temp], 0 ) = = 0 :
q.append(m[temp])
c + = 1
if c > K:
break
print (ans)
# 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)
|
using System;
using System.Collections.Generic;
namespace BinaryTreeKDistanceSum
{ 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 ;
}
}
class Program
{
static TreeNode InsertNode( int data, TreeNode root)
{
if (root == null )
{
TreeNode node = new TreeNode(data);
return node;
}
else if (data > root.data)
{
root.right = InsertNode(data, root.right);
}
else if (data <= root.data)
{
root.left = InsertNode(data, root.left);
}
return root;
}
static void FindSum(TreeNode root, int target, int K)
{
int ans = 0;
Queue<TreeNode> q = new Queue<TreeNode>();
q.Enqueue(root);
TreeNode need = null ;
Dictionary<TreeNode, TreeNode> m = new Dictionary<TreeNode, TreeNode>();
while (q.Count > 0)
{
int s = q.Count;
for ( int i = 0; i < s; i++)
{
TreeNode temp = q.Dequeue();
if (temp.data == target) need = temp;
if (temp.left != null )
{
q.Enqueue(temp.left);
m[temp.left] = temp;
}
if (temp.right != null )
{
q.Enqueue(temp.right);
m[temp.right] = temp;
}
}
}
Dictionary<TreeNode, int > mm = new Dictionary<TreeNode, int >();
q.Enqueue(need);
int c = 0;
while (q.Count > 0)
{
int s = q.Count;
for ( int i = 0; i < s; i++)
{
TreeNode temp = q.Dequeue();
mm[temp] = 1;
if (temp.data < target && c == K)
{
ans += temp.data;
}
if (temp.left != null && !mm.ContainsKey(temp.left))
{
q.Enqueue(temp.left);
}
if (temp.right != null && !mm.ContainsKey(temp.right))
{
q.Enqueue(temp.right);
}
if (m.ContainsKey(temp) && !mm.ContainsKey(m[temp]))
{
q.Enqueue(m[temp]);
}
}
c++;
if (c > K) break ;
}
Console.WriteLine(ans);
}
static void Main( string [] args)
{
TreeNode root = null ;
int N = 11;
int [] tree = { 3, 1, 7, 0, 2, 5, 10, 4, 6, 9, 8 };
for ( int i = 0; i < N; i++)
{
root = InsertNode(tree[i], root);
}
int target = 7;
int K = 2;
FindSum(root, target, K);
}
}
} |
class TreeNode { constructor(data) {
this .data = data;
this .left = null ;
this .right = null ;
}
} // Function to insert a node into the Binary Search Tree (BST) function insertNode(data, root) {
if (root === null ) {
const node = new TreeNode(data);
return node;
}
if (data > root.data) {
root.right = insertNode(data, root.right);
} else if (data <= root.data) {
root.left = insertNode(data, root.left);
}
return root;
} // Function to find the sum of K distant nodes from the target // node having values less than the target node function findSum(root, target, K) {
let ans = 0; // Variable to store the sum
const queue = [root]; // Initialize a queue for BFS
let need = null ; // Node to store the target node
const parentMap = new Map(); // Map to store the parent of each node
// Perform BFS to find the target node and build the parent map
while (queue.length > 0) {
const levelSize = queue.length;
for (let i = 0; i < levelSize; i++) {
const temp = queue.shift();
if (temp.data === target) {
need = temp; // Found the target node
}
if (temp.left !== null ) {
queue.push(temp.left);
parentMap.set(temp.left, temp);
}
if (temp.right !== null ) {
queue.push(temp.right);
parentMap.set(temp.right, temp);
}
}
}
const mm = new Map(); // Map to track visited nodes
queue.push(need); // Initialize the queue with the target node
let distance = 0; // Initialize the distance from the target node
// Perform BFS to calculate the sum of nodes at distance K from the target node
while (queue.length > 0) {
const levelSize = queue.length;
for (let i = 0; i < levelSize; i++) {
const temp = queue.shift();
mm.set(temp, 1); // Mark the node as visited
if (temp.data < target && distance === K) {
ans += temp.data; // Add the node's value to the sum if it meets the criteria
}
if (temp.left !== null && mm.get(temp.left) !== 1) {
queue.push(temp.left); // Explore the left child if not visited
}
if (temp.right !== null && mm.get(temp.right) !== 1) {
queue.push(temp.right); // Explore the right child if not visited
}
if (parentMap.has(temp) && mm.get(parentMap.get(temp)) !== 1) {
queue.push(parentMap.get(temp)); // Explore the parent if not visited
}
}
distance++;
if (distance > K) {
break ; // Stop the BFS when the desired distance is reached
}
}
console.log(ans); // Print the final sum
} // Driver Code function main() {
let root = null ;
const N = 11;
const tree = [3, 1, 7, 0, 2, 5, 10, 4, 6, 9, 8];
// Create the BST by inserting elements from the 'tree' array
for (let i = 0; i < N; i++) {
root = insertNode(tree[i], root);
}
const target = 7;
const K = 2;
findSum(root, target, K); // Find and display the sum
} main(); |
11
Time Complexity:- O(N)
Auxiliary Space:- O(N)