Replace each node in binary tree with the sum of its inorder predecessor and successor

Last Updated : 4 Nov, 2024

Given a binary tree containing n nodes. The task is to replace each node in the binary tree with the sum of its inorder predecessor and inorder successor.

Examples: 

Input:

replace-each-node-in-binary-tree-with-the-sum-of-its-inorder-predecessor-and-successor


Output:

replace-each-node-in-binary-tree-with-the-sum-of-its-inorder-predecessor-and-successor-02

Table of Content

[Expected Approach - 1] Using In-Order Traversal and Array - O(n) Time and O(n) Space

Create an array arr. Store 0 at index 0. Now, store the in-order traversal of tree in the array arr. Then, store 0 at last index. 0’s are stored as inorder predecessor of leftmost leaf and inorder successor of rightmost leaf is not present. Now, perform inorder traversal and while traversing node replace node’s value with arr[i-1] + arr[i+1] and then increment i. 

In the beginning initialize i = 1. For an element arr[i], the values arr[i-1] and arr[i+1] are its inorder predecessor and inorder successor respectively.

Below is the implementation of the above approach:

C++ 
// C++ program to replace each node 
// in binary tree with the sum of 
// its inorder predecessor and successor
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node* left, *right;
    Node (int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};

// Recursive Function which will replace node value 
void replaceNodeRecur(Node* root, int &index, vector<int> &arr) {
    if (root == nullptr) return;
    
    replaceNodeRecur(root->left, index, arr);
    
    // replace the node value.
    root->data = arr[index-1] + arr[index+1];
    index++;
    
    replaceNodeRecur(root->right, index, arr);
}

// Function to store in-order traversal in array.
void storeInorder(Node* root, vector<int> &arr) {
    if (root == nullptr) return;
    
    storeInorder(root->left, arr);
    arr.push_back(root->data);
    storeInorder(root->right, arr);
}

// Function to replace the nodes with 
// sum of inorder predecessor and successor.
void replaceNodeWithSum(Node* root) {
    if (root == nullptr) return;
    
    // Array to store inorder traversal.
    vector<int> arr;
    arr.push_back(0);
    
    // Store in-order 
    storeInorder(root, arr);
    arr.push_back(0);
    
    int index = 1;
    replaceNodeRecur(root, index, arr);
}

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

int main() {
    
    // Binary tree
    //       1
    //      / \
    //     2   3
    //   / \  / \
    //  3   5 6  7
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->left = new Node(4);
    root->left->right = new Node(5);
    root->right->left = new Node(6);
    root->right->right = new Node(7);
    
    replaceNodeWithSum(root); 
    inOrder(root);
    return 0;
}
Java 
// Java program to replace each node 
// in binary tree with the sum of 
// its inorder predecessor and successor

import java.util.ArrayList;

class Node {
    int data;
    Node left, right;

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

class GfG {

    // Recursive Function which will replace node value 
    static void replaceNodeRecur(Node root, int[] index,
                                 ArrayList<Integer> arr) {
        if (root == null) return;

        replaceNodeRecur(root.left, index, arr);

        // replace the node value.
        root.data = arr.get(index[0] - 1) + arr.get(index[0] + 1);
        index[0]++;

        replaceNodeRecur(root.right, index, arr);
    }

    // Function to store in-order traversal in array.
    static void storeInorder(Node root, ArrayList<Integer> arr) {
        if (root == null) return;

        storeInorder(root.left, arr);
        arr.add(root.data);
        storeInorder(root.right, arr);
    }

    // Function to replace the nodes with 
    // sum of inorder predecessor and successor.
    static void replaceNodeWithSum(Node root) {
        if (root == null) return;

        // Array to store inorder traversal.
        ArrayList<Integer> arr = new ArrayList<>();
        arr.add(0);

        // Store in-order 
        storeInorder(root, arr);
        arr.add(0);

        int[] index = {1};
        replaceNodeRecur(root, index, arr);
    }

    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) {
        
        // Binary tree
        //       1
        //      / \
        //     2   3
        //   / \  / \
        //  3   5 6  7
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.left = new Node(6);
        root.right.right = new Node(7);

        replaceNodeWithSum(root);
        inOrder(root);
    }
}
Python 
# Python program to replace each node 
# in binary tree with the sum of 
# its inorder predecessor and successor

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

# Recursive Function which will replace
# node value 
def replaceNodeRecur(root, index, arr):
    if root is None:
        return

    replaceNodeRecur(root.left, index, arr)

    # replace the node value.
    root.data = arr[index[0] - 1] + arr[index[0] + 1]
    index[0] += 1

    replaceNodeRecur(root.right, index, arr)

# Function to store in-order traversal 
# in array.
def storeInorder(root, arr):
    if root is None:
        return

    storeInorder(root.left, arr)
    arr.append(root.data)
    storeInorder(root.right, arr)

# Function to replace the nodes with 
# sum of inorder predecessor and successor.
def replaceNodeWithSum(root):
    if root is None:
        return

    # Array to store inorder traversal.
    arr = [0]

    # Store in-order 
    storeInorder(root, arr)
    arr.append(0)

    index = [1]
    replaceNodeRecur(root, index, arr)

def inOrder(root):
    if root is None:
        return

    inOrder(root.left)
    print(root.data, end=" ")
    inOrder(root.right)

if __name__ == "__main__":
    
    # Binary tree
    #       1
    #      / \
    #     2   3
    #   / \  / \
    #  3   5 6  7
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(4)
    root.left.right = Node(5)
    root.right.left = Node(6)
    root.right.right = Node(7)

    replaceNodeWithSum(root)
    inOrder(root)
C# 
// C# program to replace each node 
// in binary tree with the sum of 
// its inorder predecessor and successor
using System;
using System.Collections.Generic;

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

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

class GfG {
    
    // Recursive Function which will replace 
  	// node value 
    static void replaceNodeRecur(Node root, 
				ref int index, List<int> arr) {
        if (root == null) return;

        replaceNodeRecur(root.left, ref index, arr);

        // replace the node value.
        root.data = arr[index - 1] + arr[index + 1];
        index++;

        replaceNodeRecur(root.right, ref index, arr);
    }

    // Function to store in-order traversal in array.
    static void storeInorder(Node root, List<int> arr) {
        if (root == null) return;

        storeInorder(root.left, arr);
        arr.Add(root.data);
        storeInorder(root.right, arr);
    }

    // Function to replace the nodes with 
    // sum of inorder predecessor and successor.
    static void replaceNodeWithSum(Node root) {
        if (root == null) return;

        // Array to store inorder traversal.
        List<int> arr = new List<int> { 0 };

        // Store in-order 
        storeInorder(root, arr);
        arr.Add(0);

        int index = 1;
        replaceNodeRecur(root, ref index, arr);
    }

    static void inOrder(Node root) {
        if (root == null) return;

        inOrder(root.left);
        Console.Write(root.data + " ");
        inOrder(root.right);
    }

    static void Main() {
        
        // Binary tree
        //       1
        //      / \
        //     2   3
        //   / \  / \
        //  3   5 6  7
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.left = new Node(6);
        root.right.right = new Node(7);

        replaceNodeWithSum(root);
        inOrder(root);
    }
}
JavaScript 
// JavaScript program to replace each node 
// in binary tree with the sum of 
// its inorder predecessor and successor

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

// Recursive Function which will replace node value 
function replaceNodeRecur(root, index, arr) {
    if (root === null) return;

    replaceNodeRecur(root.left, index, arr);

    // replace the node value.
    root.data = arr[index[0] - 1] + arr[index[0] + 1];
    index[0]++;

    replaceNodeRecur(root.right, index, arr);
}

// Function to store in-order traversal in array.
function storeInorder(root, arr) {
    if (root === null) return;

    storeInorder(root.left, arr);
    arr.push(root.data);
    storeInorder(root.right, arr);
}

// Function to replace the nodes with 
// sum of inorder predecessor and successor.
function replaceNodeWithSum(root) {
    if (root === null) return;

    // Array to store inorder traversal.
    let arr = [0];

    // Store in-order 
    storeInorder(root, arr);
    arr.push(0);

    let index = [1];
    replaceNodeRecur(root, index, arr);
}

function inOrder(root) {
    if (root === null) return;

    inOrder(root.left);
    console.log(root.data);
    inOrder(root.right);
}

// Binary tree
//       1
//      / \
//     2   3
//   / \  / \
//  3   5 6  7
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
root.right.right = new Node(7);

replaceNodeWithSum(root);
inOrder(root);

Output
2 9 3 11 4 13 3

[Expected Approach - 2] Without Using Array - O(n) Time and O(h) Space

The idea is to perform recursive in-order traversal while maintaining the previous node pointer and previous node's predecessor value. For each node curr, set the value of previous node to sum of (predecessor value + current node value). Update previous node and predecessor value accordingly.

Below is the implementation of the above approach:

C++ 
// C++ program to replace each node 
// in binary tree with the sum of 
// its inorder predecessor and successor
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node* left, *right;
    Node (int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};

// Recursive Function which will replace node value 
void replaceNodeRecur(Node* root, int &pred, Node* &prev) {
    if (root == nullptr) return;
    
    // Recursively process left subtree.
    replaceNodeRecur(root->left, pred, prev);
    
    // If previous node exists, then
    // update its value.
    if (prev != nullptr) {
        int tmp = prev->data;
        prev->data = pred + root->data;
        
        pred = tmp;
    }
    
    // Update prev pointer
    prev = root;
    
    // Recursively process right subtree.
    replaceNodeRecur(root->right, pred, prev);
}

// Function to replace the nodes with 
// sum of inorder predecessor and successor.
void replaceNodeWithSum(Node* root) {
    if (root == nullptr) return;
    
    int pred = 0;
    Node* prev = nullptr;
    
    replaceNodeRecur(root, pred, prev);
    
    // Update the value of last node as 
    // it is not covered in in-order traversal.
    prev->data = pred;
}

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

int main() {
    
    // Binary tree
    //       1
    //      / \
    //     2   3
    //   / \  / \
    //  3   5 6  7
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->left = new Node(4);
    root->left->right = new Node(5);
    root->right->left = new Node(6);
    root->right->right = new Node(7);
    
    replaceNodeWithSum(root); 
    inOrder(root);
    return 0;
}
Java 
// Java program to replace each node 
// in binary tree with the sum of 
// its inorder predecessor and successor

class Node {
    int data;
    Node left, right;

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

class Main {

    // Recursive Function which will replace node value 
    static void replaceNodeRecur(Node root, int[] pred, Node[] prev) {
        if (root == null) return;

        // Recursively process left subtree.
        replaceNodeRecur(root.left, pred, prev);

        // If previous node exists, then
        // update its value.
        if (prev[0] != null) {
            int tmp = prev[0].data;
            prev[0].data = pred[0] + root.data;
            pred[0] = tmp;
        }

        // Update prev pointer
        prev[0] = root;

        // Recursively process right subtree.
        replaceNodeRecur(root.right, pred, prev);
    }

    // Function to replace the nodes with 
    // sum of inorder predecessor and successor.
    static void replaceNodeWithSum(Node root) {
        if (root == null) return;

        int[] pred = {0};
        Node[] prev = {null};

        replaceNodeRecur(root, pred, prev);

        // Update the value of last node as 
        // it is not covered in in-order traversal.
        prev[0].data = pred[0];
    }

    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) {

        // Binary tree
        //       1
        //      / \
        //     2   3
        //   / \  / \
        //  4   5 6  7
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.left = new Node(6);
        root.right.right = new Node(7);

        replaceNodeWithSum(root);
        inOrder(root);
    }
}
Python 
# Python program to replace each node 
# in binary tree with the sum of 
# its inorder predecessor and successor

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

# Recursive Function which will replace node value 
def replaceNodeRecur(root, pred, prev):
    if root is None:
        return
    
    # Recursively process left subtree.
    replaceNodeRecur(root.left, pred, prev)
    
    # If previous node exists, then
    # update its value.
    if prev[0] is not None:
        tmp = prev[0].data
        prev[0].data = pred[0] + root.data
        pred[0] = tmp
    
    # Update prev pointer
    prev[0] = root
    
    # Recursively process right subtree.
    replaceNodeRecur(root.right, pred, prev)

# Function to replace the nodes with 
# sum of inorder predecessor and successor.
def replaceNodeWithSum(root):
    if root is None:
        return
    
    pred = [0]
    prev = [None]
    
    replaceNodeRecur(root, pred, prev)
    
    # Update the value of last node as 
    # it is not covered in in-order traversal.
    prev[0].data = pred[0]

def inOrder(root):
    if root is None:
        return
    inOrder(root.left)
    print(root.data, end=" ")
    inOrder(root.right)

if __name__ == "__main__":

    # Binary tree
    #       1
    #      / \
    #     2   3
    #   / \  / \
    #  4   5 6  7
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(4)
    root.left.right = Node(5)
    root.right.left = Node(6)
    root.right.right = Node(7)

    replaceNodeWithSum(root)
    inOrder(root)
C# 
// C# program to replace each node 
// in binary tree with the sum of 
// its inorder predecessor and successor

using System;

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

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

class GfG {

    // Recursive Function which will replace node value 
    static void replaceNodeRecur(Node root, ref int pred, 
                                 ref Node prev) {
        if (root == null) return;

        // Recursively process left subtree.
        replaceNodeRecur(root.left, ref pred, ref prev);

        // If previous node exists, then
        // update its value.
        if (prev != null) {
            int tmp = prev.data;
            prev.data = pred + root.data;
            pred = tmp;
        }

        // Update prev pointer
        prev = root;

        // Recursively process right subtree.
        replaceNodeRecur(root.right, ref pred, ref prev);
    }

    // Function to replace the nodes with 
    // sum of inorder predecessor and successor.
    static void replaceNodeWithSum(Node root) {
        if (root == null) return;

        int pred = 0;
        Node prev = null;

        replaceNodeRecur(root, ref pred, ref prev);

        // Update the value of last node as 
        // it is not covered in in-order traversal.
        prev.data = pred;
    }

    static void inOrder(Node root) {
        if (root == null) return;

        inOrder(root.left);
        Console.Write(root.data + " ");
        inOrder(root.right);
    }

    static void Main(string[] args) {

        // Binary tree
        //       1
        //      / \
        //     2   3
        //   / \  / \
        //  4   5 6  7
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.left = new Node(6);
        root.right.right = new Node(7);

        replaceNodeWithSum(root);
        inOrder(root);
    }
}
JavaScript 
// JavaScript program to replace each node 
// in binary tree with the sum of 
// its inorder predecessor and successor

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

// Recursive Function which will replace node value 
function replaceNodeRecur(root, pred, prev) {
    if (root === null) return;

    // Recursively process left subtree.
    replaceNodeRecur(root.left, pred, prev);

    // If previous node exists, then
    // update its value.
    if (prev[0] !== null) {
        let tmp = prev[0].data;
        prev[0].data = pred[0] + root.data;
        pred[0] = tmp;
    }

    // Update prev pointer
    prev[0] = root;

    // Recursively process right subtree.
    replaceNodeRecur(root.right, pred, prev);
}

// Function to replace the nodes with 
// sum of inorder predecessor and successor.
function replaceNodeWithSum(root) {
    if (root === null) return;

    let pred = [0];
    let prev = [null];

    replaceNodeRecur(root, pred, prev);

    // Update the value of last node as 
    // it is not covered in in-order traversal.
    prev[0].data = pred[0];
}

function inOrder(root) {
    if (root === null) return;

    inOrder(root.left);
    console.log(root.data);
    inOrder(root.right);
}

// Binary tree
//       1
//      / \
//     2   3
//   / \  / \
//  4   5 6  7
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
root.right.right = new Node(7);

replaceNodeWithSum(root);
inOrder(root);

Output
2 9 3 11 4 13 3
Comment
Article Tags:
Tree
DSA
Arrays

Explore