Name: BST to a Tree with sum of all smaller keys
Uploaded: 2022-06-03T12:04:06Z
Duration: 4 min 3 s

Given a Binary Search Tree(BST), convert it to a Binary Tree such that every key of the original BST is changed to a key plus the sum of all smaller keys in BST.

Examples:

Input:

Output:

Explanation: Every key of the original BST is changed to a key plus the sum of all smaller keys in BST.

Approach:

The idea is to use recursion to traverse the tree in inorder manner while keeping a running sum of all previously visited nodes. The value of each node is updated to this running sum, which ensure that each node contains the sum of all nodes less than or equal to it.

Below is the implementation of the above approach:

C++

// C++ program to transform a BST to
// lesser sum tree

#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node* left;
    Node* right;

    Node(int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};

// Recursive function to transform the BST
// to hold the sum of all smaller or equal keys
void transformToSmallerSumTree(Node* root, int& sum) {
    if (root == nullptr) {
        return;
    }

    // Traverse the left subtree first (smaller values)
    transformToSmallerSumTree(root->left, sum);

    // Update the sum and the current node's value
    // Running sum of all smaller keys
    sum += root->data;         
    
    // Update the node's value to the sum
    root->data = sum;          

    // Traverse the right subtree (larger values)
    transformToSmallerSumTree(root->right, sum);
}

// Function to initiate the transformation
void transformTree(Node* root) {
    
    // Variable to store cumulative sum
    int sum = 0;
    transformToSmallerSumTree(root, sum);
}

void inorder(Node* root) {
    if (root == nullptr) {
        return;
    }
    inorder(root->left);
    cout << root->data << " ";
    inorder(root->right);
}

int main() {
    
    // Constructing the BST
    //     11
    //    /  \
    //   2    29
    //  / \   / \
    // 1   7 15  40
    //             \
    //              50

    Node* root = new Node(11);
    root->left = new Node(2);
    root->right = new Node(29);
    root->left->left = new Node(1);
    root->left->right = new Node(7);
    root->right->left = new Node(15);
    root->right->right = new Node(40);
    root->right->right->right = new Node(50);

    transformTree(root);
    inorder(root);
    cout << endl;

    return 0;
}

// C program to transform a BST to 
// lesser sum tree

#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};

// Recursive function to transform the BST
// to hold the sum of all smaller or equal keys
void transformToSmallerSumTree(struct Node* root, int* sum) {
    if (root == NULL) {
        return;
    }

    // Traverse the left subtree first (smaller values)
    transformToSmallerSumTree(root->left, sum);

    // Update the sum and the current node's value
    // Running sum of all smaller keys
    *sum += root->data;

    // Update the node's value to the sum
    root->data = *sum;

    // Traverse the right subtree (larger values)
    transformToSmallerSumTree(root->right, sum);
}

// Function to initiate the transformation
void transformTree(struct Node* root) {

    // Variable to store cumulative sum
    int sum = 0;
    transformToSmallerSumTree(root, &sum);
}

// Inorder traversal to print the tree
void inorder(struct Node* root) {
    if (root == NULL) {
        return;
    }
    inorder(root->left);
    printf("%d ", root->data);
    inorder(root->right);
}

struct Node* createNode(int x) {
    struct Node* node = 
      (struct Node*)malloc(sizeof(struct Node));
    node->data = x;
    node->left = node->right = NULL;
    return node;
}

int main() {

    // Constructing the BST
    //     11
    //    /  \
    //   2    29
    //  / \   / \
    // 1   7 15  40
    //             \
    //              50

    struct Node* root = createNode(11);
    root->left = createNode(2);
    root->right = createNode(29);
    root->left->left = createNode(1);
    root->left->right = createNode(7);
    root->right->left = createNode(15);
    root->right->right = createNode(40);
    root->right->right->right = createNode(50);

    transformTree(root);
    inorder(root);
    printf("\n");

    return 0;
}

Java

// Java program to transform a BST
// to lesser sum tree

import java.util.*;

class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {

    // Recursive function to transform the BST
    // to hold the sum of all smaller or equal keys
    static void transformToSmallerSumTree(Node root, int[] sum) {
        if (root == null) {
            return;
        }

        // Traverse the left subtree first (smaller values)
        transformToSmallerSumTree(root.left, sum);

        // Update the sum and the current node's value
        // Running sum of all smaller keys
        sum[0] += root.data;

        // Update the node's value to the sum
        root.data = sum[0];

        // Traverse the right subtree (larger values)
        transformToSmallerSumTree(root.right, sum);
    }

    // Function to initiate the transformation
    static void transformTree(Node root) {

        // Variable to store cumulative sum
        int[] sum = {0};
        transformToSmallerSumTree(root, sum);
    }

    static void inorder(Node root) {
        if (root == null) {
            return;
        }
        inorder(root.left);
        System.out.print(root.data + " ");
        inorder(root.right);
    }

    public static void main(String[] args) {

        // Constructing the BST
        //     11
        //    /  \
        //   2    29
        //  / \   / \
        // 1   7 15  40
        //             \
        //              50

        Node root = new Node(11);
        root.left = new Node(2);
        root.right = new Node(29);
        root.left.left = new Node(1);
        root.left.right = new Node(7);
        root.right.left = new Node(15);
        root.right.right = new Node(40);
        root.right.right.right = new Node(50);

        transformTree(root);
        inorder(root);
        System.out.println();
    }
}

Python

# Python program to transform a BST 
# to lesser sum tree

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

# Recursive function to transform the BST
# to hold the sum of all smaller or equal keys
def transformToSmallerSumTree(root, sum):
    if root is None:
        return

    # Traverse the left subtree first (smaller values)
    transformToSmallerSumTree(root.left, sum)

    # Update the sum and the current node's value
    # Running sum of all smaller keys
    sum[0] += root.data

    # Update the node's value to the sum
    root.data = sum[0]

    # Traverse the right subtree (larger values)
    transformToSmallerSumTree(root.right, sum)

# Function to initiate the transformation
def transformTree(root):

    # Variable to store cumulative sum
    sum = [0]
    transformToSmallerSumTree(root, sum)

# Inorder traversal to print the tree
def inorder(root):
    if root is None:
        return
    inorder(root.left)
    print(root.data, end=" ")
    inorder(root.right)


if __name__ == "__main__":
  
    # Constructing the BST
    #     11
    #    /  \
    #   2    29
    #  / \   / \
    # 1   7 15  40
    #             \
    #              50
    root = Node(11)
    root.left = Node(2)
    root.right = Node(29)
    root.left.left = Node(1)
    root.left.right = Node(7)
    root.right.left = Node(15)
    root.right.right = Node(40)
    root.right.right.right = Node(50)

    transformTree(root)
    inorder(root)
    print()

// C# program to transform a BST 
// to lesser sum tree

using System;

class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {

    // Recursive function to transform the BST
    // to hold the sum of all smaller or equal keys
    static void transformToSmallerSumTree(Node root, ref int sum) {
        if (root == null) {
            return;
        }

        // Traverse the left subtree first (smaller values)
        transformToSmallerSumTree(root.left, ref sum);

        // Update the sum and the current node's value
        // Running sum of all smaller keys
        sum += root.data;

        // Update the node's value to the sum
        root.data = sum;

        // Traverse the right subtree (larger values)
        transformToSmallerSumTree(root.right, ref sum);
    }

    // Function to initiate the transformation
    static void transformTree(Node root) {

        // Variable to store cumulative sum
        int sum = 0;
        transformToSmallerSumTree(root, ref sum);
    }

    static void inorder(Node root) {
        if (root == null) {
            return;
        }
        inorder(root.left);
        Console.Write(root.data + " ");
        inorder(root.right);
    }

    static void Main(string[] args) {

        // Constructing the BST
        //     11
        //    /  \
        //   2    29
        //  / \   / \
        // 1   7 15  40
        //             \
        //              50

        Node root = new Node(11);
        root.left = new Node(2);
        root.right = new Node(29);
        root.left.left = new Node(1);
        root.left.right = new Node(7);
        root.right.left = new Node(15);
        root.right.right = new Node(40);
        root.right.right.right = new Node(50);

        transformTree(root);
        inorder(root);
        Console.WriteLine();
    }
}

JavaScript

// JavaScript program to transform 
// a BST to lesser sum tree

class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

// Recursive function to transform the BST
// to hold the sum of all smaller or equal keys
function transformToSmallerSumTree(root, sum) {
    if (root === null) {
        return;
    }

    // Traverse the left subtree first (smaller values)
    transformToSmallerSumTree(root.left, sum);

    // Update the sum and the current node's value
    // Running sum of all smaller keys
    sum.value += root.data;

    // Update the node's value to the sum
    root.data = sum.value;

    // Traverse the right subtree (larger values)
    transformToSmallerSumTree(root.right, sum);
}

// Function to initiate the transformation
function transformTree(root) {

    // Variable to store cumulative sum
    let sum = { value: 0 };
    transformToSmallerSumTree(root, sum);
}

// Inorder traversal to print the tree
function inorder(root) {
    if (root === null) {
        return;
    }
    inorder(root.left);
    console.log(root.data + " ");
    inorder(root.right);
}

// Constructing the BST
//     11
//    /  \
//   2    29
//  / \   / \
// 1   7 15  40
//             \
//              50

let root = new Node(11);
root.left = new Node(2);
root.right = new Node(29);
root.left.left = new Node(1);
root.left.right = new Node(7);
root.right.left = new Node(15);
root.right.right = new Node(40);
root.right.right.right = new Node(50);

transformTree(root);
inorder(root);

Output

1 3 10 21 36 65 105 155

Time Complexity: O(n), where n is the number of nodes in given Binary Tree, as it does a simple traversal of the tree.
Auxiliary Space: O(h), where h is the height of tree.

BST to a Tree with sum of all smaller keys

Explore