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

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 Treestruct 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 nodevoid 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 treeint 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 BSTTreeNode* 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 nodevoid 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 Codeint 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 approachimport java.util.*; public class GFG{    static int sum;   // Structure of Treestatic 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 nodestatic 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 treestatic 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 BSTstatic 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 nodestatic 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 Codepublic 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 Treesum = 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 nodedef 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 treedef 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 BSTdef 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 nodedef 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 Codeif __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 approachusing System; public class GFG{    static int sum;   // Structure of Treepublic  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 nodestatic 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 treestatic 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 BSTstatic 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 nodestatic 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 Codepublic 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.

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++

 // C++ program for the above approach #include using namespace std; // Structure of Treestruct 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 BSTTreeNode* 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 nodevoid findSum(TreeNode* root, int target,             int K){    //variable to store answer    int ans = 0;     //queue for bfs    queue q;     q.push(root);     //to store target node    TreeNode* need;     //map to store parent of each node    unordered_map m;     //bfs    while(q.size()){       int s = q.size();       //traversing to current level      for(int i=0;idata==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 mm;     q.push(need);     //to store current distance    int c = 0;     while(q.size()){       int s = q.size();       for(int i=0;idatadata;         //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<

Java

 import java.util.*; // Structure of Treeclass 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 q = new LinkedList<>();         q.add(root);         // to store target node        TreeNode need = null;         // map to store parent of each node        HashMap 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 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);    }}

Python

 from collections import deque # Structure of Treeclass TreeNode:    def __init__(self, data):        self.data = data        self.left = None        self.right = None # Function to insert a node in BSTdef 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 nodedef 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 Codeif __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)

C#

 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 q = new Queue();            q.Enqueue(root);             TreeNode need = null;            Dictionary m = new Dictionary();            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 mm = new Dictionary();            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);        }    }}

Javascript

 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 nodefunction 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 Codefunction 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)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next