# Bottom View of a Binary Tree

• Difficulty Level : Medium
• Last Updated : 24 Jun, 2022

Given a Binary Tree, we need to print the bottom view from left to right. A node x is there in output if x is the bottommost node at its horizontal distance. The horizontal distance of the left child of a node x is equal to a horizontal distance of x minus 1, and that of a right child is the horizontal distance of x plus 1.

Examples:

```                      20
/    \
8       22
/   \      \
5      3      25
/ \
10    14```

For the above tree, the output should be 5, 10, 3, 14, 25.

If there are multiple bottom-most nodes for a horizontal distance from the root, then print the later one in the level traversal. For example, in the below diagram, 3 and 4 are both the bottom-most nodes at a horizontal distance of 0, we need to print 4.

```                      20
/    \
8       22
/   \    /   \
5      3 4     25
/ \
10    14```

For the above tree, the output should be 5 10 4 14 25.

Method 1 (Using Queue): The following are steps to print the Bottom View of the Binary Tree.

1. We put tree nodes in a queue for the level order traversal.
2. Start with the horizontal distance(hd) 0 of the root node, and keep on adding a left child to the queue along with the horizontal distance as hd-1 and the right child as hd+1.
3. Also, use a TreeMap which stores key-value pairs sorted on key.
4. Every time, we encounter a new horizontal distance or an existing horizontal distance put the node data for the horizontal distance as the key. For the first time it will add to the map, next time it will replace the value. This will make sure that the bottom-most element for that horizontal distance is present on the map and if you see the tree from beneath that you will see that element.

Below is the implementation of the above:

## C++

 `// C++ Program to print Bottom View of Binary Tree ` `#include ` `using` `namespace` `std; ` ` `  `// Tree node class ` `struct` `Node ` `{ ` `    ``int` `data; ``//data of the node ` `    ``int` `hd; ``//horizontal distance of the node ` `    ``Node *left, *right; ``//left and right references ` ` `  `    ``// Constructor of tree node ` `    ``Node(``int` `key) ` `    ``{ ` `        ``data = key; ` `        ``hd = INT_MAX; ` `        ``left = right = NULL; ` `    ``} ` `}; ` ` `  `// Method that prints the bottom view. ` `void` `bottomView(Node *root) ` `{ ` `    ``if` `(root == NULL) ` `        ``return``; ` ` `  `    ``// Initialize a variable 'hd' with 0 ` `    ``// for the root element. ` `    ``int` `hd = 0; ` ` `  `    ``// TreeMap which stores key value pair ` `    ``// sorted on key value ` `    ``map<``int``, ``int``> m; ` ` `  `    ``// Queue to store tree nodes in level ` `    ``// order traversal ` `    ``queue q; ` ` `  `    ``// Assign initialized horizontal distance ` `    ``// value to root node and add it to the queue. ` `    ``root->hd = hd; ` `    ``q.push(root);  ``// In STL, push() is used enqueue an item ` ` `  `    ``// Loop until the queue is empty (standard ` `    ``// level order loop) ` `    ``while` `(!q.empty()) ` `    ``{ ` `        ``Node *temp = q.front(); ` `        ``q.pop();   ``// In STL, pop() is used dequeue an item ` ` `  `        ``// Extract the horizontal distance value ` `        ``// from the dequeued tree node. ` `        ``hd = temp->hd; ` ` `  `        ``// Put the dequeued tree node to TreeMap ` `        ``// having key as horizontal distance. Every ` `        ``// time we find a node having same horizontal ` `        ``// distance we need to replace the data in ` `        ``// the map. ` `        ``m[hd] = temp->data; ` ` `  `        ``// If the dequeued node has a left child, add ` `        ``// it to the queue with a horizontal distance hd-1. ` `        ``if` `(temp->left != NULL) ` `        ``{ ` `            ``temp->left->hd = hd-1; ` `            ``q.push(temp->left); ` `        ``} ` ` `  `        ``// If the dequeued node has a right child, add ` `        ``// it to the queue with a horizontal distance ` `        ``// hd+1. ` `        ``if` `(temp->right != NULL) ` `        ``{ ` `            ``temp->right->hd = hd+1; ` `            ``q.push(temp->right); ` `        ``} ` `    ``} ` ` `  `    ``// Traverse the map elements using the iterator. ` `    ``for` `(``auto` `i = m.begin(); i != m.end(); ++i) ` `        ``cout << i->second << ``" "``; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``Node *root = ``new` `Node(20); ` `    ``root->left = ``new` `Node(8); ` `    ``root->right = ``new` `Node(22); ` `    ``root->left->left = ``new` `Node(5); ` `    ``root->left->right = ``new` `Node(3); ` `    ``root->right->left = ``new` `Node(4); ` `    ``root->right->right = ``new` `Node(25); ` `    ``root->left->right->left = ``new` `Node(10); ` `    ``root->left->right->right = ``new` `Node(14); ` `    ``cout << ``"Bottom view of the given binary tree :\n"``; ` `    ``bottomView(root); ` `    ``return` `0; ` `}`

## Java

 `// Java Program to print Bottom View of Binary Tree ` `import` `java.util.*; ` `import` `java.util.Map.Entry; ` ` `  `// Tree node class ` `class` `Node ` `{ ` `    ``int` `data; ``//data of the node ` `    ``int` `hd; ``//horizontal distance of the node ` `    ``Node left, right; ``//left and right references ` ` `  `    ``// Constructor of tree node ` `    ``public` `Node(``int` `key) ` `    ``{ ` `        ``data = key; ` `        ``hd = Integer.MAX_VALUE; ` `        ``left = right = ``null``; ` `    ``} ` `} ` ` `  `//Tree class ` `class` `Tree ` `{ ` `    ``Node root; ``//root node of tree ` ` `  `    ``// Default constructor ` `    ``public` `Tree() {} ` ` `  `    ``// Parameterized tree constructor ` `    ``public` `Tree(Node node) ` `    ``{ ` `        ``root = node; ` `    ``} ` ` `  `    ``// Method that prints the bottom view. ` `    ``public` `void` `bottomView() ` `    ``{ ` `        ``if` `(root == ``null``) ` `            ``return``; ` ` `  `        ``// Initialize a variable 'hd' with 0 for the root element. ` `        ``int` `hd = ``0``; ` ` `  `        ``// TreeMap which stores key value pair sorted on key value ` `        ``Map map = ``new` `TreeMap<>(); ` ` `  `         ``// Queue to store tree nodes in level order traversal ` `        ``Queue queue = ``new` `LinkedList(); ` ` `  `        ``// Assign initialized horizontal distance value to root ` `        ``// node and add it to the queue. ` `        ``root.hd = hd; ` `        ``queue.add(root); ` ` `  `        ``// Loop until the queue is empty (standard level order loop) ` `        ``while` `(!queue.isEmpty()) ` `        ``{ ` `            ``Node temp = queue.remove(); ` ` `  `            ``// Extract the horizontal distance value from the ` `            ``// dequeued tree node. ` `            ``hd = temp.hd; ` ` `  `            ``// Put the dequeued tree node to TreeMap having key ` `            ``// as horizontal distance. Every time we find a node ` `            ``// having same horizontal distance we need to replace ` `            ``// the data in the map. ` `            ``map.put(hd, temp.data); ` ` `  `            ``// If the dequeued node has a left child add it to the ` `            ``// queue with a horizontal distance hd-1. ` `            ``if` `(temp.left != ``null``) ` `            ``{ ` `                ``temp.left.hd = hd-``1``; ` `                ``queue.add(temp.left); ` `            ``} ` `            ``// If the dequeued node has a right child add it to the ` `            ``// queue with a horizontal distance hd+1. ` `            ``if` `(temp.right != ``null``) ` `            ``{ ` `                ``temp.right.hd = hd+``1``; ` `                ``queue.add(temp.right); ` `            ``} ` `        ``} ` ` `  `        ``// Extract the entries of map into a set to traverse ` `        ``// an iterator over that. ` `        ``Set> set = map.entrySet(); ` ` `  `        ``// Make an iterator ` `        ``Iterator> iterator = set.iterator(); ` ` `  `        ``// Traverse the map elements using the iterator. ` `        ``while` `(iterator.hasNext()) ` `        ``{ ` `            ``Map.Entry me = iterator.next(); ` `            ``System.out.print(me.getValue()+``" "``); ` `        ``} ` `    ``} ` `} ` ` `  `// Main driver class ` `public` `class` `BottomView ` `{ ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``Node root = ``new` `Node(``20``); ` `        ``root.left = ``new` `Node(``8``); ` `        ``root.right = ``new` `Node(``22``); ` `        ``root.left.left = ``new` `Node(``5``); ` `        ``root.left.right = ``new` `Node(``3``); ` `        ``root.right.left = ``new` `Node(``4``); ` `        ``root.right.right = ``new` `Node(``25``); ` `        ``root.left.right.left = ``new` `Node(``10``); ` `        ``root.left.right.right = ``new` `Node(``14``); ` `        ``Tree tree = ``new` `Tree(root); ` `        ``System.out.println(``"Bottom view of the given binary tree:"``); ` `        ``tree.bottomView(); ` `    ``} ` `}`

## Python3

 `# Python3 program to print Bottom ` `# View of Binary Tree ` ` `  `# deque supports efficient pish and pop on both ends ` `from` `collections ``import` `deque ` `  `  `# Tree node class ` `class` `Node: ` `     `  `    ``def` `__init__(``self``, key): ` `         `  `        ``self``.data ``=` `key ` `        ``self``.hd ``=` `float``(``'inf'``) ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` `  `  `# Method that prints the bottom view. ` `def` `bottomView(root): ` ` `  `    ``if` `(root ``=``=` `None``): ` `        ``return` `     `  `    ``# Initialize a variable 'hd' with 0 ` `    ``# for the root element. ` `    ``hd ``=` `0` `     `  `    ``# Store minimum and maximum horizontal distance ` `    ``# so that we do not have to sort keys at the end ` `    ``min_hd, max_hd ``=` `0``, ``0` `     `  `    ``hd_dict ``=` `dict``() ` `  `  `    ``# Queue to store tree nodes in level ` `    ``# order traversal ` `    ``q ``=` `deque() ` `  `  `    ``# Assign initialized horizontal distance ` `    ``# value to root node and add it to the queue. ` `    ``root.hd ``=` `hd ` `    ``q.append(root)   ` `  `  `    ``# Loop until the queue is empty (standard ` `    ``# level order loop) ` `    ``while` `q: ` `        ``curr_node ``=` `q.popleft() ` `          `  `        ``# Extract the horizontal distance value ` `        ``# from the dequeued tree node. ` `        ``hd ``=` `curr_node.hd ` `         `  `        ``# Update the minimum and maximum hd ` `        ``min_hd ``=` `min``(min_hd, hd) ` `        ``max_hd ``=` `max``(max_hd, hd) ` `  `  `        ``# Put the dequeued tree node to dictionary ` `        ``# having key as horizontal distance. Every ` `        ``# time we find a node having same horizontal ` `        ``# distance we need to update the value in ` `        ``# the map. ` `        ``hd_dict[hd] ``=` `curr_node.data ` `  `  `        ``# If the dequeued node has a left child, add ` `        ``# it to the queue with a horizontal distance hd-1. ` `        ``if` `curr_node.left: ` `            ``curr_node.left.hd ``=` `hd ``-` `1` `            ``q.append(curr_node.left) ` `  `  `        ``# If the dequeued node has a right child, add ` `        ``# it to the queue with a horizontal distance ` `        ``# hd+1. ` `        ``if` `curr_node.right: ` `            ``curr_node.right.hd ``=` `hd ``+` `1` `            ``q.append(curr_node.right) ` `  `  `    ``# Traverse the map from least horizontal distance to ` `    ``# most horizontal distance. ` `    ``for` `i ``in` `range``(min_hd, max_hd``+``1``): ` `        ``print``(hd_dict[i], end ``=` `' '``) ` `         `  `# Driver Code ` `if` `__name__``=``=``'__main__'``: ` `     `  `    ``root ``=` `Node(``20``) ` `    ``root.left ``=` `Node(``8``) ` `    ``root.right ``=` `Node(``22``) ` `    ``root.left.left ``=` `Node(``5``) ` `    ``root.left.right ``=` `Node(``3``) ` `    ``root.right.left ``=` `Node(``4``) ` `    ``root.right.right ``=` `Node(``25``) ` `    ``root.left.right.left ``=` `Node(``10``) ` `    ``root.left.right.right ``=` `Node(``14``) ` `     `  `    ``print``(``"Bottom view of the given binary tree :"``) ` `     `  `    ``bottomView(root) ` `     `  `# This code is contributed by rutvik_56`

## C#

 `// C# program to print Bottom View of Binary Tree ` `using` `System; ` `using` `System.Collections; ` `using` `System.Collections.Generic; ` `  `  `// Tree node class ` `class` `Node ` `{ ` `     `  `    ``// Data of the node ` `    ``public` `int` `data;  ` `     `  `    ``// Horizontal distance of the node ` `    ``public` `int` `hd;  ` `     `  `    ``// left and right references ` `    ``public` `Node left, right; ` `     `  `    ``// Constructor of tree node ` `    ``public` `Node(``int` `key) ` `    ``{ ` `        ``data = key; ` `        ``hd = 1000000; ` `        ``left = right = ``null``; ` `    ``} ` `} ` ` `  `// Tree class ` `class` `Tree ` `{ ` `     `  `    ``// Root node of tree ` `    ``Node root; ` `     `  `    ``// Default constructor ` `    ``public` `Tree(){} ` `     `  `    ``// Parameterized tree constructor ` `    ``public` `Tree(Node node) ` `    ``{ ` `        ``root = node; ` `    ``} ` `  `  `    ``// Method that prints the bottom view. ` `    ``public` `void` `bottomView() ` `    ``{ ` `        ``if` `(root == ``null``) ` `            ``return``; ` `             `  `        ``// Initialize a variable 'hd' with ` `        ``// 0 for the root element. ` `        ``int` `hd = 0; ` `  `  `        ``// TreeMap which stores key value ` `        ``// pair sorted on key value ` `        ``SortedDictionary<``int``, ` `                         ``int``> map = ``new` `SortedDictionary<``int``, ` `                                                         ``int``>(); ` `  `  `        ``// Queue to store tree nodes in level order ` `        ``// traversal ` `        ``Queue queue = ``new` `Queue(); ` `         `  `        ``// Assign initialized horizontal distance  ` `        ``// value to root node and add it to the queue. ` `        ``root.hd = hd; ` `        ``queue.Enqueue(root); ` `  `  `        ``// Loop until the queue is empty  ` `        ``// (standard level order loop) ` `        ``while` `(queue.Count != 0) ` `        ``{ ` `            ``Node temp = (Node) queue.Dequeue(); ` `  `  `            ``// Extract the horizontal distance value  ` `            ``// from the dequeued tree node. ` `            ``hd = temp.hd; ` `  `  `            ``// Put the dequeued tree node to TreeMap  ` `            ``// having key as horizontal distance. ` `            ``// Every time we find a node having same ` `            ``// horizontal distance we need to replace ` `            ``// the data in the map. ` `            ``map[hd] = temp.data; ` `  `  `            ``// If the dequeued node has a left child  ` `            ``// add it to the queue with a horizontal ` `            ``// distance hd-1. ` `            ``if` `(temp.left != ``null``) ` `            ``{ ` `                ``temp.left.hd = hd - 1; ` `                ``queue.Enqueue(temp.left); ` `            ``} ` `             `  `            ``// If the dequeued node has a right  ` `            ``// child add it to the queue with a ` `            ``// horizontal distance hd+1. ` `            ``if` `(temp.right != ``null``) ` `            ``{ ` `                ``temp.right.hd = hd + 1; ` `                ``queue.Enqueue(temp.right); ` `            ``} ` `        ``} ` `         `  `        ``foreach``(``int` `i ``in` `map.Values) ` `        ``{ ` `            ``Console.Write(i + ``" "``); ` `        ``} ` `    ``} ` `} ` `  `  `public` `class` `BottomView{ ` `   `  `// Driver code ` `public` `static` `void` `Main(``string``[] args) ` `{ ` `    ``Node root = ``new` `Node(20); ` `    ``root.left = ``new` `Node(8); ` `    ``root.right = ``new` `Node(22); ` `    ``root.left.left = ``new` `Node(5); ` `    ``root.left.right = ``new` `Node(3); ` `    ``root.right.left = ``new` `Node(4); ` `    ``root.right.right = ``new` `Node(25); ` `    ``root.left.right.left = ``new` `Node(10); ` `    ``root.left.right.right = ``new` `Node(14); ` `    ``Tree tree = ``new` `Tree(root); ` `     `  `    ``Console.WriteLine(``"Bottom view of the "` `+  ` `                      ``"given binary tree:"``); ` `     `  `    ``tree.bottomView(); ` `} ` `} ` ` `  `// This code is contributed by pratham76`

## Javascript

 ``

Output

```Bottom view of the given binary tree :
5 10 4 14 25 ```

Method 2 (Using HashMap()): Create a map where the key is the horizontal distance and the value is a pair(a, b) where a is the value of the node and b is the height of the node. Perform a pre-order traversal of the tree. If the current node at a horizontal distance of h is the first we’ve seen, insert it into the map. Otherwise, compare the node with the existing one in map and if the height of the new node is greater, update the Map.

Below is the implementation of the above:

## C++

 `// C++ Program to print Bottom View of Binary Tree ` `#include   ` `#include ` `using` `namespace` `std; ` ` `  `// Tree node class ` `struct` `Node  ` `{ ` `    ``// data of the node ` `    ``int` `data; ` `     `  `    ``// horizontal distance of the node ` `    ``int` `hd;  ` `     `  `    ``//left and right references ` `    ``Node * left, * right;  ` `     `  `    ``// Constructor of tree node ` `    ``Node(``int` `key)  ` `    ``{ ` `        ``data = key; ` `        ``hd = INT_MAX; ` `        ``left = right = NULL; ` `    ``} ` `}; ` ` `  `void` `printBottomViewUtil(Node * root, ``int` `curr, ``int` `hd, map <``int``, pair <``int``, ``int``>> & m) ` `{ ` `    ``// Base case ` `    ``if` `(root == NULL) ` `        ``return``; ` `     `  `    ``// If node for a particular  ` `    ``// horizontal distance is not ` `    ``// present, add to the map. ` `    ``if` `(m.find(hd) == m.end())  ` `    ``{ ` `        ``m[hd] = make_pair(root -> data, curr); ` `    ``}  ` `    ``// Compare height for already  ` `    ``// present node at similar horizontal ` `    ``// distance ` `    ``else`  `    ``{ ` `        ``pair < ``int``, ``int` `> p = m[hd]; ` `        ``if` `(p.second <= curr) ` `        ``{ ` `            ``m[hd].second = curr; ` `            ``m[hd].first = root -> data; ` `        ``} ` `    ``} ` `     `  `    ``// Recur for left subtree ` `    ``printBottomViewUtil(root -> left, curr + 1, hd - 1, m); ` `     `  `    ``// Recur for right subtree ` `    ``printBottomViewUtil(root -> right, curr + 1, hd + 1, m); ` `} ` ` `  `void` `printBottomView(Node * root)  ` `{ ` `     `  `    ``// Map to store Horizontal Distance, ` `    ``// Height and Data. ` `    ``map < ``int``, pair < ``int``, ``int` `> > m; ` `     `  `    ``printBottomViewUtil(root, 0, 0, m); ` `     `  `     ``// Prints the values stored by printBottomViewUtil() ` `    ``map < ``int``, pair < ``int``, ``int` `> > ::iterator it; ` `    ``for` `(it = m.begin(); it != m.end(); ++it) ` `    ``{ ` `        ``pair < ``int``, ``int` `> p = it -> second; ` `        ``cout << p.first << ``" "``; ` `    ``} ` `} ` ` `  `int` `main()  ` `{ ` `    ``Node * root = ``new` `Node(20); ` `    ``root -> left = ``new` `Node(8); ` `    ``root -> right = ``new` `Node(22); ` `    ``root -> left -> left = ``new` `Node(5); ` `    ``root -> left -> right = ``new` `Node(3); ` `    ``root -> right -> left = ``new` `Node(4); ` `    ``root -> right -> right = ``new` `Node(25); ` `    ``root -> left -> right -> left = ``new` `Node(10); ` `    ``root -> left -> right -> right = ``new` `Node(14); ` `    ``cout << ``"Bottom view of the given binary tree :\n"``; ` `    ``printBottomView(root); ` `    ``return` `0; ` `}`

## Java

 `// Java program to print Bottom View of Binary Tree  ` `import` `java.io.*; ` `import` `java.lang.*; ` `import` `java.util.*; ` ` `  `class` `GFG{ ` ` `  `// Tree node class ` `static` `class` `Node ` `{ ` `     `  `    ``// Data of the node ` `    ``int` `data; ` ` `  `    ``// Horizontal distance of the node ` `    ``int` `hd; ` ` `  `    ``// Left and right references ` `    ``Node left, right; ` ` `  `    ``// Constructor of tree node ` `    ``public` `Node(``int` `key) ` `    ``{ ` `        ``data = key; ` `        ``hd = Integer.MAX_VALUE; ` `        ``left = right = ``null``; ` `    ``} ` `} ` ` `  `static` `void` `printBottomViewUtil(Node root, ``int` `curr, ``int` `hd, ` `                                ``TreeMap m) ` `{ ` `     `  `    ``// Base case ` `    ``if` `(root == ``null``) ` `        ``return``; ` ` `  `    ``// If node for a particular ` `    ``// horizontal distance is not ` `    ``// present, add to the map. ` `    ``if` `(!m.containsKey(hd)) ` `    ``{ ` `        ``m.put(hd, ``new` `int``[]{ root.data, curr }); ` `    ``} ` `     `  `    ``// Compare height for already ` `    ``// present node at similar horizontal ` `    ``// distance ` `    ``else`  `    ``{ ` `        ``int``[] p = m.get(hd); ` `        ``if` `(p[``1``] <= curr) ` `        ``{ ` `            ``p[``1``] = curr; ` `            ``p[``0``] = root.data; ` `        ``} ` `        ``m.put(hd, p); ` `    ``} ` ` `  `    ``// Recur for left subtree ` `    ``printBottomViewUtil(root.left, curr + ``1``, ` `                        ``hd - ``1``, m); ` ` `  `    ``// Recur for right subtree ` `    ``printBottomViewUtil(root.right, curr + ``1``,  ` `                        ``hd + ``1``, m); ` `} ` ` `  `static` `void` `printBottomView(Node root) ` `{ ` ` `  `    ``// Map to store Horizontal Distance, ` `    ``// Height and Data. ` `    ``TreeMap m = ``new` `TreeMap<>(); ` ` `  `    ``printBottomViewUtil(root, ``0``, ``0``, m); ` ` `  `    ``// Prints the values stored by printBottomViewUtil() ` `    ``for``(``int` `val[] : m.values())  ` `    ``{ ` `        ``System.out.print(val[``0``] + ``" "``); ` `    ``} ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``Node root = ``new` `Node(``20``); ` `    ``root.left = ``new` `Node(``8``); ` `    ``root.right = ``new` `Node(``22``); ` `    ``root.left.left = ``new` `Node(``5``); ` `    ``root.left.right = ``new` `Node(``3``); ` `    ``root.right.left = ``new` `Node(``4``); ` `    ``root.right.right = ``new` `Node(``25``); ` `    ``root.left.right.left = ``new` `Node(``10``); ` `    ``root.left.right.right = ``new` `Node(``14``); ` ` `  `    ``System.out.println( ` `        ``"Bottom view of the given binary tree:"``); ` ` `  `    ``printBottomView(root); ` `} ` `} ` ` `  `// This code is contributed by Kingash`

## Python3

 `# Python3 program to print Bottom ` `# View of Binary Tree  ` `class` `Node: ` `     `  `    ``def` `__init__(``self``, key ``=` `None``,  ` `                      ``left ``=` `None``,  ` `                     ``right ``=` `None``): ` `                          `  `        ``self``.data ``=` `key ` `        ``self``.left ``=` `left ` `        ``self``.right ``=` `right ` `         `  `def` `printBottomView(root): ` `     `  `      ``# Create a dictionary where ` `    ``# key -> relative horizontal distance ` `    ``# of the node from root node and ` `    ``# value -> pair containing node's  ` `    ``# value and its level ` `    ``d ``=` `dict``() ` `     `  `    ``printBottomViewUtil(root, d, ``0``, ``0``) ` `     `  `    ``# Traverse the dictionary in sorted  ` `    ``# order of their keys and print ` `    ``# the bottom view ` `    ``for` `i ``in` `sorted``(d.keys()): ` `        ``print``(d[i][``0``], end ``=` `" "``) ` ` `  `def` `printBottomViewUtil(root, d, hd, level): ` `     `  `      ``# Base case ` `    ``if` `root ``is` `None``: ` `        ``return` `     `  `    ``# If current level is more than or equal  ` `    ``# to maximum level seen so far for the  ` `    ``# same horizontal distance or horizontal ` `    ``# distance is seen for the first time,  ` `    ``# update the dictionary ` `    ``if` `hd ``in` `d: ` `        ``if` `level >``=` `d[hd][``1``]: ` `            ``d[hd] ``=` `[root.data, level] ` `    ``else``: ` `        ``d[hd] ``=` `[root.data, level] ` `         `  `    ``# recur for left subtree by decreasing ` `    ``# horizontal distance and increasing ` `    ``# level by 1 ` `    ``printBottomViewUtil(root.left, d, hd ``-` `1``,  ` `                                   ``level ``+` `1``) ` `     `  `    ``# recur for right subtree by increasing ` `    ``# horizontal distance and increasing  ` `    ``# level by 1 ` `    ``printBottomViewUtil(root.right, d, hd ``+` `1``,  ` `                                    ``level ``+` `1``) ` ` `  `# Driver Code     ` `if` `__name__ ``=``=` `'__main__'``: ` `     `  `    ``root ``=` `Node(``20``) ` `    ``root.left ``=` `Node(``8``) ` `    ``root.right ``=` `Node(``22``)  ` `    ``root.left.left ``=` `Node(``5``)  ` `    ``root.left.right ``=` `Node(``3``)  ` `    ``root.right.left ``=` `Node(``4``)  ` `    ``root.right.right ``=` `Node(``25``)  ` `    ``root.left.right.left ``=` `Node(``10``)  ` `    ``root.left.right.right ``=` `Node(``14``)  ` `     `  `    ``print``(``"Bottom view of the given binary tree :"``) ` `     `  `    ``printBottomView(root) ` ` `  `# This code is contributed by tusharroy`

Output

```Bottom view of the given binary tree :
5 10 4 14 25 ```

Method 3 (Calling the function recursively):

• Step 1: First create the Node class and declare the int data, left and right nodes.
• Step 2: Create the constructor of the class node.
• Step 3: Create the main class and declare the root node. In the main method, declare and initialize the tree node values.
• Step 4: Now, call the static function print_bottom_view() with root node as argument.
• Step 5: Check whether the current node is null.
• Step 6: Now, check whether the left node and right side of the current node are null. If both the nodes are null then it will be at the bottom of the tree. The, simply print the data in that node.
• Step 7: To check for the next node, call the function in the same method by specifying print_bottom_view(n.left) and print_bottom_view(n.right). It will call the functions until the current node value becomes null.

## Java

 `/*package whatever //do not write package name here */` ` `  `import` `java.io.*; ` `class` `Node ``// tree node class ` `{ ` `  ``int` `data; ` `  ``Node right,left; ` ` ``public` `Node(``int` `d) ``//constructor of the Node ` `  ``{ ` `    ``data=d; ` `    ``left=``null``; ` `    ``right=``null``; ` `  ``} ` `} ` ` `  `class` `GFG { ` `   ``Node root; ` `   ``public` `static` `void` `print_bottom_view(Node n) ` `   ``{ ` `     ``if``(n==``null``) ``//check whether the node is null ` `       ``return``; ` `     ``if``(n.left==``null` `&& n.right==``null``) ``// check whether the right and left side of the current nodes are null ` `     ``{ ` `       ``System.out.print(n.data+``" "``); ` `     ``} ` `     ``print_bottom_view(n.left);  ` `     ``print_bottom_view(n.right);                  ` `   ``} ` `    ``public` `static` `void` `main (String[] args) { ` `      ``GFG tree=``new` `GFG();  ` `      ``tree.root=``new` `Node(``20``);   ` `      ``tree.root.left=``new` `Node(``8``);   ` `      ``tree.root.right=``new` `Node(``22``);   ` `      ``tree.root.left.left=``new` `Node(``5``);   ` `      ``tree.root.left.right=``new` `Node(``3``);   ` `      ``tree.root.right.left=``new` `Node(``4``);   ` `      ``tree.root.right.right=``new` `Node(``25``);   ` `      ``tree.root.left.right.left=``new` `Node(``10``); ` `      ``tree.root.left.right.right=``new` `Node(``14``); ` `      ``System.out.println(``"Bottom View of the Tree :"``); ` `      ``print_bottom_view(tree.root); ``//calling the function ` `       `  `    ``} ` `} ` `//contributed by keerthikarathan123`

Output

```Bottom View of the Tree :
5 10 14 4 25 ```

## Python3

 `# code ` `class` `Node: ` `      `  `    ``def` `__init__(``self``, key ``=` `None``, ` `                      ``left ``=` `None``, ` `                     ``right ``=` `None``): ` `                           `  `        ``self``.data ``=` `key ` `        ``self``.left ``=` `left ` `        ``self``.right ``=` `right ` `          `  `def` `print_bottom_view(root): ` `  ``if` `root ``is` `None``: ` `        ``return` `  ``if` `root.left ``is` `None` `and` `root.right ``is` `None` `: ` `    ``print``(root.data,end``=``" "``) ` `  ``print_bottom_view(root.left) ` `  ``print_bottom_view(root.right) ` ` `  `if` `__name__ ``=``=` `'__main__'``: ` `      `  `    ``root ``=` `Node(``20``) ` `    ``root.left ``=` `Node(``8``) ` `    ``root.right ``=` `Node(``22``) ` `    ``root.left.left ``=` `Node(``5``) ` `    ``root.left.right ``=` `Node(``3``) ` `    ``root.right.left ``=` `Node(``4``) ` `    ``root.right.right ``=` `Node(``25``) ` `    ``root.left.right.left ``=` `Node(``10``) ` `    ``root.left.right.right ``=` `Node(``14``) ` `      `  `    ``print``(``"Bottom view of the tree :"``) ` `      `  `    ``print_bottom_view(root) ` `#contributed by keerthikarathan123`

Output

```Bottom view of the tree :
5 10 14 4 25 ```

My Personal Notes arrow_drop_up
Recommended Articles
Page :