Types of Asymptotic Notations in Complexity Analysis of Algorithms

Bottom View of a Binary Tree using Recursion

Last Updated : 12 Jul, 2025

Given a Binary Tree, the task is to print the bottom view from left to right using Recursion.

Note: If there are multiple bottom-most nodes for a horizontal distance from the root, then the latter one in the level traversal is considered.

Examples:

Example1: The Green nodes represent the bottom view of below binary tree.

Example2: The Green nodes represent the bottom view of below binary tree.

In this article, we will focus on implementing the Bottom View of a Binary Tree using a recursive approach. For alternative methods and additional details, please refer to Bottom View of Binary Tree.

Approach:

We can do so by using recursion and 2 arrays each with size 2n+1(for worst case), where n = number of elements in the given tree. Here, we take a variable x which determines its Horizontal Distance. Let x is the horizontal distance of a Node. Now, the left child will have a horizontal distance of x-1(x minus 1)and the right child will have horizontal distance x+1(x plus 1). Take another variable 'p' as a priority which will decide which level this element belongs to.
While Traversing the Tree In fashion Right-> Node-> Left, assign x and p to each Node and simultaneously insert the data of node in the first array if the array is empty at position (mid+x). If the array is not empty and a Node with higher Priority(p) comes to update the array with the data of this Node as position(mid+x). The second array will be maintaining the priority(p) of each inserted node in the first array check code for better understanding.

Below is the implementation of the above approach:

C++

// C++ implementation for Bottom View of Tree
// using Recursion
#include <bits/stdc++.h>
using namespace std;

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

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

// Function to generate bottom view of binary tree
void Bottom(Node* root, vector<int>& arr,
            vector<int>& arr2, int& left, 
            int& right, int x, int p, int mid) {
  
    // Base case
    if (root == nullptr) return;

    // Update leftmost and rightmost value of x
    if (x < left) left = x;
    if (x > right) right = x;

    // Check if arr is empty at mid+x
    if (arr[mid + x] == INT_MIN) {
      
        // Insert data of Node at arr[mid+x]
        arr[mid + x] = root->data;
      
        // Insert priority of that
      	// Node at arr2[mid+x]
        arr2[mid + x] = p;
    }
  
    // If not empty and priority of previously 
    // inserted Node is less than current
    else if (arr2[mid + x] < p) {
      
        // Insert current Node data at arr[mid+x]
        arr[mid + x] = root->data;
      
        // Insert priority of that Node at 
      	// arr2[mid + x]
        arr2[mid + x] = p;
    }

    // Go right first then left
    Bottom(root->right, arr, arr2, left,
           right, x + 1, p + 1, mid);
    Bottom(root->left, arr, arr2, left,
           right, x - 1, p + 1, mid);
}

int countNodes(Node* root) {
    if (root == nullptr) {
        return 0;
    }
    return 1 + countNodes(root->left) 
                 + countNodes(root->right);
}

// Utility function to generate bottom 
// view of a binary tree
vector<int> bottomView(Node* root) {
    int n = countNodes(root);
  
    vector<int> arr(2 * n + 1, INT_MIN);  
    vector<int> arr2(2 * n + 1, INT_MIN); 

     // Leftmost horizontal distance
    int left = 0; 
  
     // Rightmost horizontal distance
    int right = 0;
    int mid = n, x = 0, p = 0;

    Bottom(root, arr, arr2, left, right, x, p, mid);

    vector<int> ans;
  
    // Store the bottom view from leftmost to rightmost
    for (int i = mid + left; i <= mid + right; i++) {
        if (arr[i] != INT_MIN) { 
            ans.push_back(arr[i]);
        }
    }
    return ans;
}

int main() {
  
    // Representation of the input tree:
    //       1
    //        \
    //         2
    //          \
    //           4
    //          / \
    //         3   5   
    Node* root = new Node(1);
    root->right = new Node(2);
    root->right->right = new Node(4);
    root->right->right->left = new Node(3);
    root->right->right->right = new Node(5);

    vector<int> result = bottomView(root);
    
    for (int val : result) {
        cout << val << " ";
    }

    return 0;
}

Java

// Java implementation for Bottom View of Tree
// using Recursion
import java.util.ArrayList;
import java.util.Collections;

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

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

// Class to generate bottom view of binary tree
class GfG {
    
    // Function to generate bottom view of binary tree
    static void Bottom(Node root, ArrayList<Integer> arr,
                ArrayList<Integer> arr2, int[] left, 
                int[] right, int x, int p, int mid) {

        // Base case
        if (root == null) return;

        // Update leftmost and rightmost value of x
        if (x < left[0]) left[0] = x;
        if (x > right[0]) right[0] = x;

        // Check if arr is empty at mid+x
        if (arr.get(mid + x) == Integer.MIN_VALUE) {

            // Insert data of Node at arr[mid+x]
            arr.set(mid + x, root.data);

            // Insert priority of that
            // Node at arr2[mid+x]
            arr2.set(mid + x, p);
        }

        // If not empty and priority of previously 
        // inserted Node is less than current
        else if (arr2.get(mid + x) < p) {

            // Insert current Node data at arr[mid+x]
            arr.set(mid + x, root.data);

            // Insert priority of that Node at arr2[mid + x]
            arr2.set(mid + x, p);
        }

        // Go right first then left
        Bottom(root.right, arr, arr2, left,
               right, x + 1, p + 1, mid);
        Bottom(root.left, arr, arr2, left,
               right, x - 1, p + 1, mid);
    }

    static int countNodes(Node root) {
        if (root == null) {
            return 0;
        }
        return 1 + countNodes(root.left) 
                     + countNodes(root.right);
    }

    // Utility function to generate bottom 
    // view of a binary tree
    static ArrayList<Integer> bottomView(Node root) {
        int n = countNodes(root);

        ArrayList<Integer> arr = new ArrayList<>(2 * n + 1);
        ArrayList<Integer> arr2 = new ArrayList<>(2 * n + 1);

        // Initialize the array lists with Integer.MIN_VALUE
        for (int i = 0; i < 2 * n + 1; i++) {
            arr.add(Integer.MIN_VALUE);
            arr2.add(Integer.MIN_VALUE);
        }

        // Leftmost horizontal distance
        int[] left = new int[1]; 
        left[0] = 0; 

        // Rightmost horizontal distance
        int[] right = new int[1];
        right[0] = 0;
        int mid = n, x = 0, p = 0;

        Bottom(root, arr, arr2, left, right, x, p, mid);

        ArrayList<Integer> ans = new ArrayList<>();

        // Store the bottom view from leftmost to rightmost
        for (int i = mid + left[0]; i <= mid + right[0]; i++) {
            if (arr.get(i) != Integer.MIN_VALUE) { 
                ans.add(arr.get(i));
            }
        }
        return ans;
    }

    public static void main(String[] args) {
      
        // Representation of the input tree:
        //       1
        //        \
        //         2
        //          \
        //           4
        //          / \
        //         3   5   
        Node root = new Node(1);
        root.right = new Node(2);
        root.right.right = new Node(4);
        root.right.right.left = new Node(3);
        root.right.right.right = new Node(5);

        ArrayList<Integer> result = bottomView(root);
        
        for (int val : result) {
            System.out.print(val + " ");
        }
       
    }
}

Python

# Python implementation for Bottom View of Tree
# using Recursion
class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

# Function to generate bottom view of binary tree
def Bottom(root, arr, arr2, left, 
                           right, x, p, mid):
  
    # Base case
    if root is None:
        return

    # Update leftmost and rightmost value of x
    if x < left[0]:
        left[0] = x
    if x > right[0]:
        right[0] = x

    # Check if arr is empty at mid+x
    if arr[mid + x] == float('-inf'):
      
        # Insert data of Node at arr[mid+x]
        arr[mid + x] = root.data
      
        # Insert priority of that Node
        # at arr2[mid+x]
        arr2[mid + x] = p
  
    # If not empty and priority of previously 
    # inserted Node is less than current
    elif arr2[mid + x] < p:
      
        # Insert current Node data at arr[mid+x]
        arr[mid + x] = root.data
      
        # Insert priority of that Node at arr2[mid + x]
        arr2[mid + x] = p

    # Go right first then left
    Bottom(root.right, arr, arr2, left, \
                    right, x + 1, p + 1, mid)
    Bottom(root.left, arr, arr2, left, \
                    right, x - 1, p + 1, mid)

def countNodes(root):
    if root is None:
        return 0
    return 1 + countNodes(root.left) + countNodes(root.right)

# Utility function to generate bottom 
# view of a binary tree
def bottomView(root):
    N = countNodes(root)
  
    arr = [float('-inf')] * (2 * N + 1)
    arr2 = [float('-inf')] * (2 * N + 1)

    # Leftmost horizontal distance
    left = [0] 
  
    # Rightmost horizontal distance
    right = [0]
    mid = N
    x = 0
    p = 0

    Bottom(root, arr, arr2, left, right, x, p, mid)

    ans = []
  
    # Store the bottom view from leftmost to rightmost
    for i in range(mid + left[0], mid + right[0] + 1):
        if arr[i] != float('-inf'): 
            ans.append(arr[i])
    return ans
  
if __name__ == "__main__":
    root = Node(1)
    root.right = Node(2)
    root.right.right = Node(4)
    root.right.right.left = Node(3)
    root.right.right.right = Node(5)

    result = bottomView(root)
    
    for val in result:
        print(val, end=" ")

// C# implementation for Bottom View of Tree
// using Recursion
using System;
using System.Collections.Generic;

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

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

// Class to generate bottom view of 
// binary tree
class GfG {
    
    // Function to generate bottom view of binary tree
    static void Bottom(Node root, List<int> arr,
                List<int> arr2, int[] left, 
                int[] right, int x, int p, int mid) {

        // Base case
        if (root == null) return;

        // Update leftmost and rightmost value of x
        if (x < left[0]) left[0] = x;
        if (x > right[0]) right[0] = x;

        // Check if arr is empty at mid+x
        if (arr[mid + x] == int.MinValue) {

            // Insert data of Node at arr[mid+x]
            arr[mid + x] = root.data;

            // Insert priority of that
            // Node at arr2[mid+x]
            arr2[mid + x] = p;
        }

        // If not empty and priority of previously 
        // inserted Node is less than current
        else if (arr2[mid + x] < p) {

            // Insert current Node data at arr[mid+x]
            arr[mid + x] = root.data;

            // Insert priority of that Node at 
          	// arr2[mid + x]
            arr2[mid + x] = p;
        }

        // Go right first then left
        Bottom(root.right, arr, arr2, left,
               right, x + 1, p + 1, mid);
        Bottom(root.left, arr, arr2, left,
               right, x - 1, p + 1, mid);
    }

    static int countNodes(Node root) {
        if (root == null) {
            return 0;
        }
        return 1 + countNodes(root.left) 
                     + countNodes(root.right);
    }

    // Utility function to generate bottom 
    // view of a binary tree
    static List<int> bottomView(Node root) {
        int N = countNodes(root);

        List<int> arr = new List<int>(new int[2 * N + 1]);
        List<int> arr2 = new List<int>(new int[2 * N + 1]);

        // Initialize the array lists with int.MinValue
        for (int i = 0; i < 2 * N + 1; i++) {
            arr[i] = int.MinValue;
            arr2[i] = int.MinValue;
        }

        // Leftmost horizontal distance
        int[] left = new int[1]; 
        left[0] = 0; 

        // Rightmost horizontal distance
        int[] right = new int[1];
        right[0] = 0;
        int mid = N, x = 0, p = 0;

        Bottom(root, arr, arr2, left, right, x, p, mid);

        List<int> ans = new List<int>();

        // Store the bottom view from leftmost to rightmost
        for (int i = mid + left[0]; i <= mid + 
             					right[0]; i++) {
            if (arr[i] != int.MinValue) { 
                ans.Add(arr[i]);
            }
        }
        return ans;
    }

    static void Main(string[] args) {
      
        // Representation of the input tree:
        //       1
        //        \
        //         2
        //          \
        //           4
        //          / \
        //         3   5   
        Node root = new Node(1);
        root.right = new Node(2);
        root.right.right = new Node(4);
        root.right.right.left = new Node(3);
        root.right.right.right = new Node(5);

        List<int> result = bottomView(root);
        
        foreach (int val in result) {
            Console.Write(val + " ");
        }
       
    }
}

JavaScript

// JavaScript implementation for Bottom View of Tree
// using Recursion

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

// Function to generate bottom view of binary tree
function Bottom(root, arr, arr2, left, right, x, p, mid) {

    // Base case
    if (root === null) return;

    // Update leftmost and rightmost value of x
    if (x < left[0]) left[0] = x;
    if (x > right[0]) right[0] = x;

    // Check if arr is empty at mid+x
    if (arr[mid + x] === Number.MIN_SAFE_INTEGER) {

        // Insert data of Node at arr[mid+x]
        arr[mid + x] = root.data;

        // Insert priority of that
        // Node at arr2[mid+x]
        arr2[mid + x] = p;
    }

    // If not empty and priority of previously 
    // inserted Node is less than current
    else if (arr2[mid + x] < p) {

        // Insert current Node data at arr[mid+x]
        arr[mid + x] = root.data;

        // Insert priority of that Node at arr2[mid + x]
        arr2[mid + x] = p;
    }

    // Go right first then left
    Bottom(root.right, arr, arr2, left,
           right, x + 1, p + 1, mid);
    Bottom(root.left, arr, arr2, left,
           right, x - 1, p + 1, mid);
}

function countNodes(root) {
    if (root === null) {
        return 0;
    }
    return 1 + countNodes(root.left) + 
    			countNodes(root.right);
}

// Utility function to generate bottom 
// view of a binary tree
function bottomView(root) {
    const N = countNodes(root);

    const arr = new Array(2 * N + 1)
    			.fill(Number.MIN_SAFE_INTEGER);
    const arr2 = new Array(2 * N + 1)
    			.fill(Number.MIN_SAFE_INTEGER);

    // Leftmost horizontal distance
    const left = [0];

    // Rightmost horizontal distance
    const right = [0];
    const mid = N;
    const x = 0;
    const p = 0;

    Bottom(root, arr, arr2, left, right, x, p, mid);

    const ans = [];

    // Store the bottom view from leftmost to rightmost
    for (let i = mid + left[0]; i <= mid + right[0]; i++) {
        if (arr[i] !== Number.MIN_SAFE_INTEGER) {
            ans.push(arr[i]);
        }
    }
    return ans;
}

// Representation of the input tree:
//       1
//        \
//         2
//          \
//           4
//          / \
//         3   5   
const root = new Node(1);
root.right = new Node(2);
root.right.right = new Node(4);
root.right.right.left = new Node(3);
root.right.right.right = new Node(5);

const result = bottomView(root);
result.forEach(val => {
        console.log(val + " ");
    });

Output

1 3 4 5

Time Complexity: O(n), where n is number of nodes in a given binary tree
Auxiliary space: O(n), for implicit call stack as using recursion

Types of Asymptotic Notations in Complexity Analysis of Algorithms

badrivishal142

Improve

Article Tags :

Bottom View of a Binary Tree using Recursion

Similar Reads

Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?