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>
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.
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();
Output
11
Time Complexity:- O(N)
Auxiliary Space:- O(N)
