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:
#include <bits/stdc++.h> 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 ;
// To store leftmost value of x in l
if (x < 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;
} // This code is contributed by Sania Kumari Gupta // (kriSania804) |
#include <limits.h> #include <stdio.h> #include <stdlib.h> typedef struct Node {
int data;
struct Node *left, *right;
} Node; /* Helper function that allocates a new node with the given data and NULL left and right pointers. */
Node* newNode( int data)
{ Node* new_node = (Node*) malloc ( sizeof (Node));
new_node->data = data;
new_node->left = new_node->right = NULL;
return new_node;
} 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 ;
// To store leftmost value of x in l
if (x < 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++)
printf ( "%d " , arr[i]);
} // Driver code int main()
{ N = 5;
Node* root = newNode(1);
root->right = newNode(2);
root->right->right = newNode(4);
root->right->right->left = newNode(3);
root->right->right->right = newNode(5);
bottomView(root);
return 0;
} // This code is contributed by Sania Kumari Gupta // (kriSania804) |
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 ;
// To store leftmost value of x in l
if (x < 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 Sania Kumari Gupta // (kriSania804) |
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 |
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 |
<script> class Node{ // Constructor of tree Node
constructor(key)
{
this .data = key;
this .left = null ;
this .right = null ;
}
}; var l = 0, r = 0, N;
// Function to generate // bottom view of binary tree function Bottom(root, arr, arr2, x, p, 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] == -1000000000)
{
// 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 function bottomView(root)
{ var arr = Array(2*N +1).fill(-1000000000);
var arr2 = Array(2*N +1).fill(-1000000000);
var mid = N, x = 0, p = 0;
Bottom(root, arr, arr2, x, p, mid);
for ( var i = mid + l; i <= mid + r; i++)
{
document.write(arr[i] + " " );
}
} // Driver code N = 5; var 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); </script> |
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