# Bottom View of a Binary Tree using Recursion

• Difficulty Level : Medium
• Last Updated : 22 Jun, 2021

Given a binary tree, the task is to find the bottom view of a binary tree using recursion.

Examples:

```Input:
1
\
2
\
4
/  \
3    5
Output: 1 3 4 5

Input:
20
/    \
8       22
/   \    /   \
5      10 21     25
/ \
9    14

Output: 5 9 21 14 25```

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.

```    1 (x=0, p=0)
\
2 (x=1, p=1)
\
4 (x=2, p=2)
/  \
(x=1, p=3) 3     5 (x=3, p=3)```

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 above approach:

## C++

 `#include ` `using` `namespace` `std;`   `struct` `Node {` `    ``int` `data;` `    ``// left and right references` `    ``Node *left, *right;` `    ``// Constructor of tree Node` `    ``Node(``int` `key)` `    ``{` `        ``data = key;` `        ``left = right = NULL;` `    ``}` `};`   `int` `l = 0, r = 0;` `int` `N;`   `// Function to generate` `// bottom view of` `// binary tree` `void` `Bottom(Node* root, ``int` `arr[], ``int` `arr2[], ``int` `x, ``int` `p, ``int` `mid)` `{` `    ``// Base case` `    ``if` `(root == NULL) {` `        ``return``;` `    ``}`   `    ``if` `(x < l) {` `        ``// To store leftmost` `        ``// value of x in l` `        ``l = x;` `    ``}`   `    ``// To store rightmost` `    ``// value of x in r` `    ``if` `(x > r) {` `        ``r = x;` `    ``}`   `    ``// To 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 priotiy` `    ``// 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 priotiy of` `        ``// that Node at arr2[mid +x]` `        ``arr2[mid + x] = p;` `    ``}`   `    ``// Go right first` `    ``// then left` `    ``Bottom(root->right, arr, arr2, x + 1, p + 1, mid);` `    ``Bottom(root->left, arr, arr2, x - 1, p + 1, mid);` `}`   `// Utility function` `// to generate bottom` `// view of a biany tree` `void` `bottomView(``struct` `Node* root)` `{` `    ``int` `arr[2 * N + 1];` `    ``int` `arr2[2 * N + 1];`   `    ``for` `(``int` `i = 0; i < 2 * N + 1; i++) {` `        ``arr[i] = INT_MIN;` `        ``arr2[i] = INT_MIN;` `    ``}`   `    ``int` `mid = N, x = 0, p = 0;`   `    ``Bottom(root, arr, arr2, x, p, mid);`   `    ``for` `(``int` `i = mid + l; i <= mid + r; i++) {` `        ``cout << arr[i] << ``" "``;` `    ``}` `}`   `// Driver code` `int` `main()` `{`   `    ``N = 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);`   `    ``bottomView(root);`   `    ``return` `0;` `}`

## Java

 `class` `GFG{` `    `  `static` `class` `Node` `{` `    ``int` `data;` `    `  `    ``// left and right references` `    ``Node left, right;` `    `  `    ``// Constructor of tree Node` `    ``public` `Node(``int` `key) ` `    ``{` `        ``data = key;` `        ``left = right = ``null``;` `    ``}` `};`   `static` `int` `l = ``0``, r = ``0``, N;`   `// Function to generate` `// bottom view of binary tree` `static` `void` `Bottom(Node root, ``int` `arr[], ` `                  ``int` `arr2[], ``int` `x, ` `                       ``int` `p, ``int` `mid)` `{` `    `  `    ``// Base case` `    ``if` `(root == ``null``) ` `    ``{` `        ``return``;` `    ``}`   `    ``if` `(x < l)` `    ``{` `        `  `        ``// To store leftmost` `        ``// value of x in l` `        ``l = x;` `    ``}`   `    ``// To store rightmost` `    ``// value of x in r` `    ``if` `(x > r) ` `    ``{` `        ``r = x;` `    ``}`   `    ``// To check if arr` `    ``// is empty at mid+x` `    ``if` `(arr[mid + x] == Integer.MIN_VALUE) ` `    ``{` `        `  `        ``// 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 priotiy` `    ``// 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 priotiy of` `        ``// that Node at arr2[mid +x]` `        ``arr2[mid + x] = p;` `    ``}`   `    ``// Go right first` `    ``// then left` `    ``Bottom(root.right, arr, arr2, ` `           ``x + ``1``, p + ``1``, mid);` `    ``Bottom(root.left, arr, arr2, ` `           ``x - ``1``, p + ``1``, mid);` `}`   `// Utility function to generate ` `// bottom view of a biany tree` `static` `void` `bottomView(Node root) ` `{` `    ``int``[] arr = ``new` `int``[``2` `* N + ``1``];` `    ``int``[] arr2 = ``new` `int``[``2` `* N + ``1``];`   `    ``for``(``int` `i = ``0``; i < ``2` `* N + ``1``; i++)` `    ``{` `        ``arr[i] = Integer.MIN_VALUE;` `        ``arr2[i] = Integer.MIN_VALUE;` `    ``}`   `    ``int` `mid = N, x = ``0``, p = ``0``;`   `    ``Bottom(root, arr, arr2, x, p, mid);`   `    ``for``(``int` `i = mid + l; i <= mid + r; i++) ` `    ``{` `        ``System.out.print(arr[i] + ``" "``);` `    ``}` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    ``N = ``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``);`   `    ``bottomView(root);` `}` `}`   `// This code is contributed by sanjeev2552`

## Python3

 `class` `Node: ` `    ``def` `__init__(``self``, data): ` `        ``self``.data ``=` `data ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `l ``=` `0` `r ``=` `0` `INT_MIN ``=` `-``(``2``*``*``32``)`   `# Function to generate ` `# bottom view of ` `# binary tree ` `def` `Bottom(root, arr, arr2, x, p, mid):` `    ``global` `INT_MIN, l, r` `    `  `    ``# Base case ` `    ``if` `(root ``=``=` `None``):` `        ``return` `    `  `    ``if` `(x < l):` `        `  `        ``# To store leftmost ` `        ``# value of x in l ` `        ``l ``=` `x ` `    `  `    ``# To store rightmost ` `    ``# value of x in r ` `    ``if` `(x > r):` `        ``r ``=` `x ` `        `  `    ``# To 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 priotiy ` `    ``# 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 priotiy of ` `        ``# that Node at arr2[mid +x] ` `        ``arr2[mid ``+` `x] ``=` `p ` `    `  `    ``# Go right first ` `    ``# then left ` `    ``Bottom(root.right, arr, arr2, x ``+` `1``, p ``+` `1``, mid) ` `    ``Bottom(root.left, arr, arr2, x ``-` `1``, p ``+` `1``, mid) `   `# Utility function ` `# to generate bottom ` `# view of a biany tree ` `def` `bottomView(root):` `    ``global` `INT_MIN` `    ``arr ``=` `[``0``]``*``(``2` `*` `N ``+` `1``) ` `    ``arr2 ``=` `[``0``]``*``(``2` `*` `N ``+` `1``)` `    `  `    ``for` `i ``in` `range``(``2` `*` `N ``+` `1``):` `        ``arr[i] ``=` `INT_MIN ` `        ``arr2[i] ``=` `INT_MIN ` `    ``mid ``=` `N` `    ``x ``=` `0` `    ``p ``=` `0` `    ``Bottom(root, arr, arr2, x, p, mid) ` `    `  `    ``for` `i ``in` `range``(mid ``+` `l,mid ``+` `r ``+` `1``):` `        ``print``(arr[i], end ``=` `" "``)` `        `  `# Driver code ` `N ``=` `5` `root ``=` `Node(``1``) ` `root.right ``=` `Node(``2``) ` `root.right.right ``=` `Node(``4``) ` `root.right.right.left ``=` `Node(``3``) ` `root.right.right.right ``=` `Node(``5``) `   `bottomView(root) ` `    `  `# This code is contributed by SHUBHAMSINGH10`

## C#

 `using` `System;`   `class` `GFG{` `    `  `class` `Node{` `    `  `public` `int` `data;`   `// left and right references` `public` `Node left, right;`   `// Constructor of tree Node` `public` `Node(``int` `key) ` `{` `    ``data = key;` `    ``left = right = ``null``;` `}` `};`   `static` `int` `l = 0, r = 0, N;`   `// Function to generate` `// bottom view of binary tree` `static` `void` `Bottom(Node root, ``int` `[]arr, ` `                  ``int` `[]arr2, ``int` `x, ` `                       ``int` `p, ``int` `mid)` `{` `    `  `    ``// Base case` `    ``if` `(root == ``null``) ` `    ``{` `        ``return``;` `    ``}`   `    ``if` `(x < l)` `    ``{` `        `  `        ``// To store leftmost` `        ``// value of x in l` `        ``l = x;` `    ``}`   `    ``// To store rightmost` `    ``// value of x in r` `    ``if` `(x > r) ` `    ``{` `        ``r = x;` `    ``}`   `    ``// To check if arr` `    ``// is empty at mid+x` `    ``if` `(arr[mid + x] == Int32.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 priotiy` `    ``// 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 priotiy of` `        ``// that Node at arr2[mid +x]` `        ``arr2[mid + x] = p;` `    ``}`   `    ``// Go right first` `    ``// then left` `    ``Bottom(root.right, arr, arr2, ` `           ``x + 1, p + 1, mid);` `    ``Bottom(root.left, arr, arr2, ` `           ``x - 1, p + 1, mid);` `}`   `// Utility function to generate ` `// bottom view of a biany tree` `static` `void` `bottomView(Node root) ` `{` `    ``int``[] arr = ``new` `int``[2 * N + 1];` `    ``int``[] arr2 = ``new` `int``[2 * N + 1];`   `    ``for``(``int` `i = 0; i < 2 * N + 1; i++)` `    ``{` `        ``arr[i] = Int32.MinValue;` `        ``arr2[i] = Int32.MinValue;` `    ``}`   `    ``int` `mid = N, x = 0, p = 0;`   `    ``Bottom(root, arr, arr2, x, p, mid);`   `    ``for``(``int` `i = mid + l; i <= mid + r; i++) ` `    ``{` `        ``Console.Write(arr[i] + ``" "``);` `    ``}` `}`   `// Driver code` `public` `static` `void` `Main(``string``[] args)` `{` `    ``N = 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);`   `    ``bottomView(root);` `}` `}`   `// This code is contributed by rutvik_56`

## Javascript

 ``

Output:

`1 3 4 5`

My Personal Notes arrow_drop_up
Recommended Articles
Page :