Convert a BST to a Binary Tree such that sum of all greater keys is added to every key

02 Feb, 2022
Given a Binary Search Tree (BST), convert it to a Binary Tree such that every key of the original BST is changed to key plus sum of all greater keys in BST. Examples: 
Input: Root of following BST
              5
            /   \
           2     13

Output: The given BST is converted to following Binary Tree
              18
            /   \
          20     13
Method 1:Solution: Do reverse In order traversal. Keep track of the sum of nodes visited so far. Let this sum be sum. For every node currently being visited, first add the key of this node to sum, i.e. sum = sum + node->key. Then change the key of current node to sum, i.e., node->key = sum. When a BST is being traversed in reverse In order, for every key currently being visited, all keys that are already visited are all greater keys. 
C++
C
Java
Python3
C#
Javascript
// C++ Program to change a BST to Binary Tree// such that key of a node becomes original// key plus sum of all greater keys in BST#include <bits/stdc++.h>using namespace std; /* A BST node has key, left child   and right child */struct node{    int key;    struct node* left;    struct node* right;}; /* Helper function that allocates a new nodewith the given key and NULL left and right pointers.*/struct node* newNode(int key){    struct node* node = (struct node*)malloc(sizeof(struct node));    node->key = key;    node->left = NULL;    node->right = NULL;    return (node);} // A recursive function that traverses the// given BST in reverse inorder and for// every key, adds all greater keys to itvoid addGreaterUtil(struct node *root, int *sum_ptr){    // Base Case    if (root == NULL)        return;     // Recur for right subtree first so that sum    // of all greater nodes is stored at sum_ptr    addGreaterUtil(root->right, sum_ptr);     // Update the value at sum_ptr    *sum_ptr = *sum_ptr + root->key;     // Update key of this node    root->key = *sum_ptr;     // Recur for left subtree so that the    // updated sum is added to smaller nodes    addGreaterUtil(root->left, sum_ptr);} // A wrapper over addGreaterUtil(). It initializes// sum and calls addGreaterUtil() to recursively// update and use value of sumvoid addGreater(struct node *root){    int sum = 0;    addGreaterUtil(root, &sum);} // A utility function to print inorder// traversal of Binary Treevoid printInorder(struct node* node){    if (node == NULL)        return;    printInorder(node->left);    cout << node->key << " " ;    printInorder(node->right);} // Driver Codeint main(){    /* Create following BST            5            / \        2 13 */    node *root = newNode(5);    root->left = newNode(2);    root->right = newNode(13);     cout << "Inorder traversal of the "         << "given tree" << endl;    printInorder(root);     addGreater(root);    cout << endl;    cout << "Inorder traversal of the "         << "modified tree" << endl;    printInorder(root);     return 0;} // This code is contributed by SHUBHAMSINGH10
// Program to change a BST to Binary Tree such that key of a node becomes// original key plus sum of all greater keys in BST#include <stdio.h>#include <stdlib.h> /* A BST node has key, left child and right child */struct node{    int key;    struct node* left;    struct node* right;}; /* Helper function that allocates a new node with the given key and   NULL left and right  pointers.*/struct node* newNode(int key){    struct node* node = (struct node*)malloc(sizeof(struct node));    node->key = key;    node->left = NULL;    node->right = NULL;    return (node);} // A recursive function that traverses the given BST in reverse inorder and// for every key, adds all greater keys to itvoid addGreaterUtil(struct node *root, int *sum_ptr){    // Base Case    if (root == NULL)        return;     // Recur for right subtree first so that sum of all greater    // nodes is stored at sum_ptr    addGreaterUtil(root->right, sum_ptr);     // Update the value at sum_ptr    *sum_ptr = *sum_ptr + root->key;     // Update key of this node    root->key = *sum_ptr;     // Recur for left subtree so that the updated sum is added    // to smaller nodes    addGreaterUtil(root->left, sum_ptr);} // A wrapper over addGreaterUtil().  It initializes sum and calls// addGreaterUtil() to recursivel upodate and use value of sumvoid addGreater(struct node *root){    int sum = 0;    addGreaterUtil(root, &sum);} // A utility function to print inorder traversal of Binary Treevoid printInorder(struct node* node){    if (node == NULL)        return;    printInorder(node->left);    printf("%d ", node->key);    printInorder(node->right);} // Driver program to test above functionint main(){    /* Create following BST              5            /   \           2     13  */    node *root = newNode(5);    root->left = newNode(2);    root->right = newNode(13);     printf("Inorder traversal of the given tree\n");    printInorder(root);     addGreater(root);     printf("\nInorder traversal of the modified tree\n");    printInorder(root);     return 0;}
// Java program to convert BST to binary tree such that sum of// all greater keys is added to every key class Node {     int data;    Node left, right;     Node(int d) {        data = d;        left = right = null;    }} class Sum {     int sum = 0;} class BinaryTree {     static Node root;    Sum summ = new Sum();     // A recursive function that traverses the given BST in reverse inorder and    // for every key, adds all greater keys to it    void addGreaterUtil(Node node, Sum sum_ptr) {         // Base Case        if (node == null) {            return;        }         // Recur for right subtree first so that sum of all greater        // nodes is stored at sum_ptr        addGreaterUtil(node.right, sum_ptr);         // Update the value at sum_ptr        sum_ptr.sum = sum_ptr.sum + node.data;         // Update key of this node        node.data = sum_ptr.sum;         // Recur for left subtree so that the updated sum is added        // to smaller nodes        addGreaterUtil(node.left, sum_ptr);    }     // A wrapper over addGreaterUtil().  It initializes sum and calls    // addGreaterUtil() to recursivel upodate and use value of sum    Node addGreater(Node node) {        addGreaterUtil(node, summ);        return node;    }     // A utility function to print inorder traversal of Binary Tree    void printInorder(Node node) {        if (node == null) {            return;        }        printInorder(node.left);        System.out.print(node.data + " ");        printInorder(node.right);    }     // Driver program to test the above functions    public static void main(String[] args) {        BinaryTree tree = new BinaryTree();        tree.root = new Node(5);        tree.root.left = new Node(2);        tree.root.right = new Node(13);         System.out.println("Inorder traversal of given tree ");        tree.printInorder(root);        Node node = tree.addGreater(root);        System.out.println("");        System.out.println("Inorder traversal of modified tree ");        tree.printInorder(node);    }} // This code has been contributed by Mayank Jaiswal
# Python3 Program to change a BST to# Binary Tree such that key of a node# becomes original key plus sum of all# greater keys in BST # A BST node has key, left child and# right child */class Node:     # Constructor to create a new node    def __init__(self, data):        self.key = data        self.left = None        self.right = None # A recursive function that traverses# the given BST in reverse inorder and# for every key, adds all greater keys to itdef addGreaterUtil(root, sum_ptr):         # Base Case    if root == None:        return     # Recur for right subtree first so that sum    # of all greater nodes is stored at sum_ptr    addGreaterUtil(root.right, sum_ptr)     # Update the value at sum_ptr    sum_ptr[0] = sum_ptr[0] + root.key     # Update key of this node    root.key = sum_ptr[0]     # Recur for left subtree so that the    # updated sum is added to smaller nodes    addGreaterUtil(root.left, sum_ptr) # A wrapper over addGreaterUtil(). It initializes# sum and calls addGreaterUtil() to recursive# update and use value of sumdef addGreater(root):    Sum = [0]    addGreaterUtil(root, Sum)     # A utility function to print inorder# traversal of Binary Treedef printInorder(node):    if node == None:        return    printInorder(node.left)    print(node.key, end = " ")    printInorder(node.right) # Driver Codeif __name__ == '__main__':         # Create following BST    #         5    #     / \    #     2     13    root = Node(5)    root.left = Node(2)    root.right = Node(13)     print("Inorder traversal of the given tree")    printInorder(root)     addGreater(root)    print()    print("Inorder traversal of the modified tree")    printInorder(root) # This code is contributed by PranchalK
using System; // C# program to convert BST to binary tree such that sum of // all greater keys is added to every key public class Node{     public int data;    public Node left, right;     public Node(int d)    {        data = d;        left = right = null;    }} public class Sum{     public int sum = 0;} public class BinaryTree{     public static Node root;    public Sum summ = new Sum();     // A recursive function that traverses the given BST in reverse inorder and    // for every key, adds all greater keys to it    public virtual void addGreaterUtil(Node node, Sum sum_ptr)    {         // Base Case        if (node == null)        {            return;        }         // Recur for right subtree first so that sum of all greater        // nodes is stored at sum_ptr        addGreaterUtil(node.right, sum_ptr);         // Update the value at sum_ptr        sum_ptr.sum = sum_ptr.sum + node.data;         // Update key of this node        node.data = sum_ptr.sum;         // Recur for left subtree so that the updated sum is added        // to smaller nodes        addGreaterUtil(node.left, sum_ptr);    }     // A wrapper over addGreaterUtil().  It initializes sum and calls    // addGreaterUtil() to recursivel upodate and use value of sum    public virtual Node addGreater(Node node)    {        addGreaterUtil(node, summ);        return node;    }     // A utility function to print inorder traversal of Binary Tree    public virtual void printInorder(Node node)    {        if (node == null)        {            return;        }        printInorder(node.left);        Console.Write(node.data + " ");        printInorder(node.right);    }     // Driver program to test the above functions    public static void Main(string[] args)    {        BinaryTree tree = new BinaryTree();        BinaryTree.root = new Node(5);        BinaryTree.root.left = new Node(2);        BinaryTree.root.right = new Node(13);         Console.WriteLine("Inorder traversal of given tree ");        tree.printInorder(root);        Node node = tree.addGreater(root);        Console.WriteLine("");        Console.WriteLine("Inorder traversal of modified tree ");        tree.printInorder(node);    }}   // This code is contributed by Shrikant13
<script> // Javascript program to convert BST to binary tree such that sum of // all greater keys is added to every keyclass Node{    constructor(d){    this.data = d;    this.left = null;    this.right = null;}} class Sum{    constructor()    {        this.sum = 0;    }} var root = null;var summ = new Sum(); // A recursive function that traverses the given BST in reverse inorder and// for every key, adds all greater keys to itfunction addGreaterUtil(node, sum_ptr){    // Base Case    if (node == null)    {        return;    }         // Recur for right subtree first so that sum of all greater    // nodes is stored at sum_ptr    addGreaterUtil(node.right, sum_ptr);         // Update the value at sum_ptr    sum_ptr.sum = sum_ptr.sum + node.data;         // Update key of this node    node.data = sum_ptr.sum;         // Recur for left subtree so that the updated sum is added    // to smaller nodes    addGreaterUtil(node.left, sum_ptr);} // A wrapper over addGreaterUtil().  It initializes sum and calls// addGreaterUtil() to recursivel upodate and use value of sumfunction addGreater(node){    addGreaterUtil(node, summ);    return node;} // A utility function to print inorder traversal of Binary Treefunction printInorder(node){    if (node == null)    {        return;    }    printInorder(node.left);    document.write(node.data + " ");    printInorder(node.right);} // Driver program to test the above functionsroot = new Node(5);root.left = new Node(2);root.right = new Node(13);document.write("Inorder traversal of given tree <br>");printInorder(root);var node = addGreater(root);document.write("<br>");document.write("Inorder traversal of modified tree <br>");printInorder(node); // This code is contributed by rrrtnx.</script>
Output: 
Inorder traversal of the given tree
2 5 13
Inorder traversal of the modified tree
20 18 13
Time Complexity: O(n) where n is the number of nodes in given Binary Search Tree.
Method 2:
The below method uses the technique of Iteration with the Stack.
Approach:
First, we initialize an empty stack and set the current node to the root.Then, so long as there are unvisited nodes in the stack or the node does not point to null, we push all of the nodes along the path to the rightmost leaf onto the stack.. Next, we visit the node on the top of our stack and consider its left subtree.Eventually, our stack is empty and the node points to the left null child of the tree’s minimum value node, so the loop terminates.
First, we initialize an empty stack and set the current node to the root.
Then, so long as there are unvisited nodes in the stack or the node does not point to null, we push all of the nodes along the path to the rightmost leaf onto the stack.
. Next, we visit the node on the top of our stack and consider its left subtree.
Eventually, our stack is empty and the node points to the left null child of the tree’s minimum value node, so the loop terminates.
Below is the implementation of the above approach:
C
C++
Java
Python3
C#
Javascript
#include <stdio.h>#include <stdlib.h>#define bool int /* A binary tree tNode has data, pointer to left childand a pointer to right child */struct tNode {    int data;    struct tNode* left;    struct tNode* right;}; /* Structure of a stack node. Linked List implementation isused for stack. A stack node contains a pointer to tree nodeand a pointer to next stack node */struct sNode {    struct tNode* t;    struct sNode* next;}; /* Stack related functions */void push(struct sNode** top_ref, struct tNode* t);struct tNode* pop(struct sNode** top_ref);bool isEmpty(struct sNode* top); /* Iterative function for inorder tree traversal */void inOrder(struct tNode* root){    /* set current to root of binary tree */    struct tNode* current = root;    struct sNode* s = NULL; /* Initialize stack s */    bool done = 0;     while (!done) {        /* Reach the left most tNode of the current tNode */        if (current != NULL) {            /* place pointer to a tree node on the stack               before traversing the node's left subtree */            push(&s, current);            current = current->left;        }         /* backtrack from the empty subtree and visit the        tNode at the top of the stack; however, if the stack        is empty, you are done */        else {            if (!isEmpty(s)) {                current = pop(&s);                printf("%d ", current->data);                 /* we have visited the node and its left                subtree. Now, it's right subtree's turn */                current = current->right;            }            else                done = 1;        }    } /* end of while */} void Greater_BST(struct tNode* root){    int sum = 0;    struct sNode* st = NULL;    struct tNode* node = root;     while (!isEmpty(st) || node != NULL) {        // push all nodes up to (and including) this        // subtree's maximum on the stack         while (node != NULL) {            push(&st, node);            node = node->right;        }         node = pop(&st);         sum += node->data;        node->data = sum;         // all nodes with values between the current and its        // parent lie in the left subtree.        node = node->left;    }} /* UTILITY FUNCTIONS *//* Function to push an item to sNode*/void push(struct sNode** top_ref, struct tNode* t){    /* allocate tNode */    struct sNode* new_tNode        = (struct sNode*)malloc(sizeof(struct sNode));     if (new_tNode == NULL) {        printf("Stack Overflow \n");        getchar();        exit(0);    }     /* put in the data */    new_tNode->t = t;     /* link the old list off the new tNode */    new_tNode->next = (*top_ref);     /* move the head to point to the new tNode */    (*top_ref) = new_tNode;} /* The function returns true if stack is empty, otherwise * false */bool isEmpty(struct sNode* top){    return (top == NULL) ? 1 : 0;} /* Function to pop an item from stack*/struct tNode* pop(struct sNode** top_ref){    struct tNode* res;    struct sNode* top;     top = *top_ref;    res = top->t;    *top_ref = top->next;    free(top);    return res;} /* Helper function that allocates a new tNode with thegiven data and NULL left and right pointers. */struct tNode* newtNode(int data){    struct tNode* tNode        = (struct tNode*)malloc(sizeof(struct tNode));    tNode->data = data;    tNode->left = NULL;    tNode->right = NULL;     return (tNode);} /* Driver program to test above functions*/int main(){     /* Let us create following BST                          8                /     \              5        12             /  \      /  \           2     7    9    15     */     struct tNode* root = newtNode(8);    root->left = newtNode(5);    root->right = newtNode(12);    root->left->left = newtNode(2);    root->left->right = newtNode(7);    root->right->left = newtNode(9);    root->right->right = newtNode(15);     Greater_BST(root);     inOrder(root);     getchar();    return 0;}
// C++ program to add all greater// values in every node of BST through Iteration using Stack#include <bits/stdc++.h>using namespace std; class Node {public:    int data;    Node *left, *right;}; // A utility function to create// a new BST nodeNode* newNode(int item){    Node* temp = new Node();    temp->data = item;    temp->left = temp->right = NULL;    return temp;} // Iterative function to add// all greater values in every nodevoid Greater_BST(Node* root){    int sum = 0;        stack<Node*> st;        Node* node = root;                 while(!st.empty() || node != NULL ){        // push all nodes up to (and including) this subtree's maximum on the stack                          while(node != NULL){                st.push(node);                node = node->right;            }                      node = st.top();            st.pop();            sum += node->data;            node->data = sum;              // all nodes with values between the current and its parent lie in the left subtree.            node = node->left;        }} // A utility function to do// inorder traversal of BSTvoid inorder(Node* root){    if (root != NULL) {        inorder(root->left);        cout << root->data << " ";        inorder(root->right);    }} /* A utility function to inserta new node with given data in BST */Node* insert(Node* node, int data){    /* If the tree is empty,    return a new node */    if (node == NULL)        return newNode(data);     /* Otherwise, recur down the tree */    if (data <= node->data)        node->left = insert(node->left, data);    else        node->right = insert(node->right, data);     /* return the (unchanged) node pointer */    return node;} // Driver codeint main(){    /* Let us create following BST              8            /     \          5        12         /  \      /  \       2     7    9    15 */       Node* root = NULL;    root = insert(root, 8);    insert(root, 5);    insert(root, 2);    insert(root, 7);    insert(root, 12);    insert(root, 9);    insert(root, 15);     Greater_BST(root);     // print inorder traversal of the Greater BST    inorder(root);     return 0;}
// Java code to add all greater values to// every node in a given BST import java.util.*; // A binary tree nodeclass Node {     int data;    Node left, right;     Node(int d)    {        data = d;        left = right = null;    }} class BinarySearchTree {     // Root of BST    Node root;     // Constructor    BinarySearchTree() { root = null; }     // Inorder traversal of the tree    void inorder() { inorderUtil(this.root); }     // Utility function for inorder traversal of    // the tree    void inorderUtil(Node node)    {        if (node == null)            return;         inorderUtil(node.left);        System.out.print(node.data + " ");        inorderUtil(node.right);    }     // adding new node    public void insert(int data)    {        this.root = this.insertRec(this.root, data);    }     /* A utility function to insert a new node with    given data in BST */    Node insertRec(Node node, int data)    {        /* If the tree is empty, return a new node */        if (node == null) {            this.root = new Node(data);            return this.root;        }         /* Otherwise, recur down the tree */        if (data <= node.data) {            node.left = this.insertRec(node.left, data);        }        else {            node.right = this.insertRec(node.right, data);        }        return node;    }     // Iterative function to add    // all greater values in every node    void Greater_BST(Node root)    {        int sum = 0;        Node node = root;        Stack<Node> stack = new Stack<Node>();         while (!stack.isEmpty() || node != null) {            /* push all nodes up to (and including) this             * subtree's maximum on the stack. */            while (node != null) {                stack.add(node);                node = node.right;            }             node = stack.pop();            sum += node.data;            node.data = sum;             /* all nodes with values between the current and             * its parent lie in the left subtree. */            node = node.left;        }    }     // Driver Function    public static void main(String[] args)    {        BinarySearchTree tree = new BinarySearchTree();         /* Let us create following BST            8         /     \   5     12  / \   / \ 2   7 9   15   */         tree.insert(8);        tree.insert(5);        tree.insert(2);        tree.insert(7);        tree.insert(12);        tree.insert(9);        tree.insert(15);         tree.Greater_BST(tree.root);         // print inorder traversal of the Greater BST        tree.inorder();    }}
# Python3 program to add all greater values# in every node of BST through Iteration using Stack # A utility function to create a# new BST nodeclass newNode:     # Constructor to create a new node    def __init__(self, data):        self.data = data        self.left = None        self.right = None  # Iterative function to add all greater# values in every node def Greater_BST(root):    total = 0             node = root    stack = []    while stack or node is not None:               # push all nodes up to (and including)        # this subtree's maximum on        # the stack.        while node is not None:            stack.append(node)            node = node.right         node = stack.pop()        total += node.data        node.data = total         # all nodes with values between        # the current and its parent lie in        # the left subtree.        node = node.left # A utility function to do inorder# traversal of BSTdef inorder(root):    if root != None:        inorder(root.left)        print(root.data, end =" ")        inorder(root.right) # A utility function to insert a new node# with given data in BSTdef insert(node, data):         # If the tree is empty, return a new node    if node == None:        return newNode(data)     # Otherwise, recur down the tree    if data <= node.data:        node.left = insert(node.left, data)    else:        node.right = insert(node.right, data)     # return the (unchanged) node pointer    return node # Driver Codeif __name__ == '__main__':         # Let us create following BST    #        8    #     /     \    #   5     12    #  / \   / \    # 2   7 9   15    root = None    root = insert(root, 8)    insert(root, 5)    insert(root, 2)    insert(root, 7)    insert(root, 9)    insert(root, 12)    insert(root, 15)     Greater_BST(root)     # print inorder traversal of the    # Greater BST    inorder(root)    
// C# code to add all greater values to// every node in a given BSTusing System;using System.Collections.Generic; // A binary tree nodepublic class Node {   public int data;  public Node left, right;   public Node(int d)  {    data = d;    left = right = null;  }} public class BinarySearchTree {   // Root of BST  Node root;   // Constructor  BinarySearchTree() { root = null; }   // Inorder traversal of the tree  void inorder() { inorderUtil(this.root); }   // Utility function for inorder traversal of  // the tree  void inorderUtil(Node node)  {    if (node == null)      return;     inorderUtil(node.left);    Console.Write(node.data + " ");    inorderUtil(node.right);  }   // adding new node  public void insert(int data)  {    this.root = this.insertRec(this.root, data);  }   /* A utility function to insert a new node with    given data in BST */  Node insertRec(Node node, int data)  {    /* If the tree is empty, return a new node */    if (node == null) {      this.root = new Node(data);      return this.root;    }     /* Otherwise, recur down the tree */    if (data <= node.data) {      node.left = this.insertRec(node.left, data);    }    else {      node.right = this.insertRec(node.right, data);    }    return node;  }   // Iterative function to add  // all greater values in every node  void Greater_BST(Node root)  {    int sum = 0;    Node node = root;    Stack<Node> stack = new Stack<Node>();     while (stack.Count!=0 || node != null) {      /* push all nodes up to (and including) this             * subtree's maximum on the stack. */      while (node != null) {        stack.Push(node);        node = node.right;      }       node = stack.Pop();      sum += node.data;      node.data = sum;       /* all nodes with values between the current and             * its parent lie in the left subtree. */      node = node.left;    }  }   // Driver Function  public static void Main(String[] args)  {    BinarySearchTree tree = new BinarySearchTree();     /* Let us create following BST            8         /     \   5     12  / \   / \ 2   7 9   15   */     tree.insert(8);    tree.insert(5);    tree.insert(2);    tree.insert(7);    tree.insert(12);    tree.insert(9);    tree.insert(15);     tree.Greater_BST(tree.root);     // print inorder traversal of the Greater BST    tree.inorder();  }} // This code is contributed by Rajput-Ji
<script>// javascript code to add all greater values to// every node in a given BST// A binary tree nodeclass Node {     constructor(d)    {        this.data = d;        this.left = this.right = null;    }}    // Root of BST    var root = null;      // Inorder traversal of the tree    function inorder() { inorderUtil(this.root); }     // Utility function for inorder traversal of    // the tree    function inorderUtil(node)    {        if (node == null)            return;         inorderUtil(node.left);        document.write(node.data + " ");        inorderUtil(node.right);    }     // adding new node     function insert(data)    {        this.root = this.insertRec(this.root, data);    }     /* A utility function to insert a new node with    given data in BST */    function insertRec(node , data)    {        /* If the tree is empty, return a new node */        if (node == null) {            this.root = new Node(data);            return this.root;        }         /* Otherwise, recur down the tree */        if (data <= node.data) {            node.left = this.insertRec(node.left, data);        }        else {            node.right = this.insertRec(node.right, data);        }        return node;    }     // Iterative function to add    // all greater values in every node    function Greater_BST(root)    {        var sum = 0;        var node = root;        var stack = [];         while (stack.length!= 0 || node != null) {            /* push all nodes up to (and including) this             * subtree's maximum on the stack. */            while (node != null) {                stack.push(node);                node = node.right;            }             node = stack.pop();            sum += node.data;            node.data = sum;             /* all nodes with values between the current and             * its parent lie in the left subtree. */            node = node.left;        }    }     // Driver Function             /*         * Let us create following BST         *                     8         /     \   5     12  / \   / \ 2   7 9   15   */         insert(8);        insert(5);        insert(2);        insert(7);        insert(12);        insert(9);        insert(15);         Greater_BST(root);         // print inorder traversal of the Greater BST        inorder(); // This code is contributed by Rajput-Ji</script>
Output:
58 56 51 44 36 27 15 
Time Complexity: O(n) , n is no.of Node in a BST.
Auxiliary Space: O(n). Stack is used for storing data.
YouTubeGeeksforGeeks501K subscribersConvert a BST to a Binary Tree so that sum of greater keys is added to every key | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 4:13•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=9zAPzXK5EaU" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
?list=PLqM7alHXFySHCXD7r1J0ky9Zg_GBB1dbkPlease write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
shrikanth13
PranchalKatiyar
SHUBHAMSINGH10
aksrathod07
anikakapoor
rrrtnx
saurabh1990aror
Rajput-Ji
sweetyty
Amazon
BST
Binary Search Tree
Amazon
Binary Search Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Red-Black Tree | Set 2 (Insert)
Inorder Successor in Binary Search Tree
Optimal Binary Search Tree | DP-24
Find the node with minimum value in a Binary Search Tree
Overview of Data Structures | Set 2 (Binary Tree, BST, Heap and Hash)
Advantages of BST over Hash Table
Lowest Common Ancestor in a Binary Search Tree.
Difference between Binary Tree and Binary Search Tree
Find k-th smallest element in BST (Order Statistics in BST)
Inorder predecessor and successor for a given key in BST