Boundary Traversal of binary tree
Last Updated : 08 Feb, 2025
Given a binary tree, the task is to find the boundary nodes of the binary tree Anti-Clockwise starting from the root.
The boundary includes:
- left boundary (nodes on left excluding leaf nodes)
- leaves (consist of only the leaf nodes)
- right boundary (nodes on right excluding leaf nodes)
The left boundary is defined as the path from the root to the left-most leaf node (excluding leaf node itself).
The right boundary is defined as the path from the root to the right-most leaf node (excluding leaf node itself).
Note: If the root doesn’t have a left subtree or right subtree, then the root itself is the left or right boundary.
[Approach – 1] Using Recursion – O(n) Time and O(h) Space
The idea is to traverse the boundary of the binary tree in three parts:
- Collect Left Boundary Nodes: Collects all nodes from the root’s left child, excluding leaf nodes, until a leaf is reached.
- Collect Leaf Nodes: Using recursion traverse the tree and collect all leaf nodes in the result.
- Collect Right Boundary Nodes: Collects all nodes from the root’s right child, excluding leaf nodes, in reverse order.
By combining these parts, we achieve the desired boundary traversal. Each part is collected using recursive functions for left boundary, leaf nodes, and right boundary traversal.
C++ //Driver Code Starts{ // C++ implementation for Boundary // Traversal of Binary Tree using recursion #include <iostream> #include <vector> using namespace std; class Node { public: int data; Node *left; Node *right; Node(int x) { data = x; left = right = nullptr; } }; //Driver Code Ends } bool isLeaf(Node *node) { return node->left == nullptr && node->right == nullptr; } // Function to collect left boundary nodes // (top-down order) void collectBoundaryLeft(Node* root, vector<int>& res) { // exclude leaf node if (root == nullptr || isLeaf(root)) return; res.push_back(root->data); if (root->left) collectBoundaryLeft(root->left, res); else if (root->right) collectBoundaryLeft(root->right, res); } // Function to collect all leaf nodes void collectLeaves(Node *root, vector<int> &res) { if (root == nullptr) return; // Add leaf nodes if (isLeaf(root)) { res.push_back(root->data); return; } collectLeaves(root->left, res); collectLeaves(root->right, res); } // Function to collect right boundary nodes // (bottom-up order) void collectBoundaryRight(Node* root, vector<int>& res) { // exclude leaf nodes if (root == nullptr || isLeaf(root)) return; if (root->right) collectBoundaryRight(root->right, res); else if (root->left) collectBoundaryRight(root->left, res); res.push_back(root->data); } // Function to find Boundary Traversal of Binary Tree vector<int> boundaryTraversal(Node *root) { vector<int> res; if (!root) return res; // Add root data if it's not a leaf if (!isLeaf(root)) res.push_back(root->data); // Collect left boundary collectBoundaryLeft(root->left, res); // Collect leaf nodes collectLeaves(root, res); // Collect right boundary collectBoundaryRight(root->right, res); return res; } //Driver Code Starts{ int main() { // Hardcoded Binary tree // 20 // / \ // 8 22 // / \ \ // 4 12 25 // / \ // 10 14 Node *root = new Node(20); root->left = new Node(8); root->right = new Node(22); root->left->left = new Node(4); root->left->right = new Node(12); root->left->right->left = new Node(10); root->left->right->right = new Node(14); root->right->right = new Node(25); vector<int> boundary = boundaryTraversal(root); for (int x : boundary) cout << x << " "; return 0; } //Driver Code Ends } //Driver Code Starts{ // Java implementation for Boundary Traversal of Binary Tree using recursion import java.util.ArrayList; class Node { int data; Node left, right; Node(int x) { data = x; left = right = null; } } class GfG { //Driver Code Ends } static boolean isLeaf(Node node) { return node.left == null && node.right == null; } // Function to collect left boundary nodes // (top-down order) static void collectBoundaryLeft(Node root, ArrayList<Integer> res) { if (root == null || isLeaf(root)) return; res.add(root.data); if (root.left != null) collectBoundaryLeft(root.left, res); else if (root.right != null) collectBoundaryLeft(root.right, res); } // Function to collect all leaf nodes static void collectLeaves(Node root, ArrayList<Integer> res) { if (root == null) return; if (isLeaf(root)) { res.add(root.data); return; } collectLeaves(root.left, res); collectLeaves(root.right, res); } // Function to collect right boundary nodes // (bottom-up order) static void collectBoundaryRight(Node root, ArrayList<Integer> res) { if (root == null || isLeaf(root)) return; if (root.right != null) collectBoundaryRight(root.right, res); else if (root.left != null) collectBoundaryRight(root.left, res); res.add(root.data); } // Function to find Boundary Traversal of Binary Tree static ArrayList<Integer> boundaryTraversal(Node root) { ArrayList<Integer> res = new ArrayList<>(); if (root == null) return res; // Add root data if it's not a leaf if (!isLeaf(root)) res.add(root.data); // Collect left boundary collectBoundaryLeft(root.left, res); // Collect leaf nodes collectLeaves(root, res); // Collect right boundary collectBoundaryRight(root.right, res); return res; } //Driver Code Starts{ public static void main(String[] args) { // Hardcoded Binary tree // 20 // / \ // 8 22 // / \ \ // 4 12 25 // / \ // 10 14 Node root = new Node(20); root.left = new Node(8); root.right = new Node(22); root.left.left = new Node(4); root.left.right = new Node(12); root.left.right.left = new Node(10); root.left.right.right = new Node(14); root.right.right = new Node(25); ArrayList<Integer> boundary = boundaryTraversal(root); for (int x : boundary) System.out.print(x + " "); } } //Driver Code Ends } #Driver Code Starts{ # Python implementation for Boundary Traversal of Binary Tree using recursion class Node: def __init__(self, x): self.data = x self.left = None self.right = None #Driver Code Ends } def isLeaf(node): return node.left is None and node.right is None # Function to collect left boundary nodes # (top-down order) def collectBoundaryLeft(root, res): if root is None or isLeaf(root): return res.append(root.data) if root.left: collectBoundaryLeft(root.left, res) elif root.right: collectBoundaryLeft(root.right, res) # Function to collect all leaf nodes def collectLeaves(root, res): if root is None: return if isLeaf(root): res.append(root.data) return collectLeaves(root.left, res) collectLeaves(root.right, res) # Function to collect right boundary nodes # (bottom-up order) def collectBoundaryRight(root, res): if root is None or isLeaf(root): return if root.right: collectBoundaryRight(root.right, res) elif root.left: collectBoundaryRight(root.left, res) res.append(root.data) # Function to find Boundary Traversal of Binary Tree def boundaryTraversal(root): res = [] if not root: return res # Add root data if it's not a leaf if not isLeaf(root): res.append(root.data) # Collect left boundary collectBoundaryLeft(root.left, res) # Collect leaf nodes collectLeaves(root, res) # Collect right boundary collectBoundaryRight(root.right, res) return res #Driver Code Starts{ if __name__ == "__main__": # Hardcoded Binary tree # 20 # / \ # 8 22 # / \ \ # 4 12 25 # / \ # 10 14 root = Node(20) root.left = Node(8) root.right = Node(22) root.left.left = Node(4) root.left.right = Node(12) root.left.right.left = Node(10) root.left.right.right = Node(14) root.right.right = Node(25) boundary = boundaryTraversal(root) print(' '.join(map(str, boundary))) #Driver Code Ends } //Driver Code Starts{ // C# implementation for Boundary // Traversal of Binary Tree using recursion using System; using System.Collections.Generic; class Node { public int data; public Node left, right; public Node(int x) { data = x; left = right = null; } } class GfG { //Driver Code Ends } static bool isLeaf(Node node) { return node.left == null && node.right == null; } // Function to collect left boundary nodes // (top-down order) static void collectBoundaryLeft(Node root, List<int> res) { if (root == null || isLeaf(root)) return; res.Add(root.data); if (root.left != null) collectBoundaryLeft(root.left, res); else if (root.right != null) collectBoundaryLeft(root.right, res); } // Function to collect all leaf nodes static void collectLeaves(Node root, List<int> res) { if (root == null) return; if (isLeaf(root)) { res.Add(root.data); return; } collectLeaves(root.left, res); collectLeaves(root.right, res); } // Function to collect right boundary nodes // (bottom-up order) static void collectBoundaryRight(Node root, List<int> res) { if (root == null || isLeaf(root)) return; if (root.right != null) collectBoundaryRight(root.right, res); else if (root.left != null) collectBoundaryRight(root.left, res); res.Add(root.data); } // Function to find Boundary Traversal of Binary Tree static List<int> boundaryTraversal(Node root) { List<int> res = new List<int>(); if (root == null) return res; // Add root data if it's not a leaf if (!isLeaf(root)) res.Add(root.data); // Collect left boundary collectBoundaryLeft(root.left, res); // Collect leaf nodes collectLeaves(root, res); // Collect right boundary collectBoundaryRight(root.right, res); return res; } //Driver Code Starts{ static void Main(string[] args) { // Hardcoded Binary tree // 20 // / \ // 8 22 // / \ \ // 4 12 25 // / \ // 10 14 Node root = new Node(20); root.left = new Node(8); root.right = new Node(22); root.left.left = new Node(4); root.left.right = new Node(12); root.left.right.left = new Node(10); root.left.right.right = new Node(14); root.right.right = new Node(25); List<int> boundary = boundaryTraversal(root); Console.WriteLine(string.Join(" ", boundary)); } } //Driver Code Ends } //Driver Code Starts{ // JavaScript implementation for Boundary Traversal of Binary Tree using recursion class Node { constructor(x) { this.data = x; this.left = null; this.right = null; } } //Driver Code Ends } function isLeaf(node) { return !node.left && !node.right; } // Function to collect left boundary nodes // (top-down order) function collectBoundaryLeft(root, res) { if (!root || isLeaf(root)) return; res.push(root.data); if (root.left) { collectBoundaryLeft(root.left, res); } else if (root.right) { collectBoundaryLeft(root.right, res); } } // Function to collect all leaf nodes function collectLeaves(root, res) { if (!root) return; if (isLeaf(root)) { res.push(root.data); return; } collectLeaves(root.left, res); collectLeaves(root.right, res); } // Function to collect right boundary nodes // (bottom-up order) function collectBoundaryRight(root, res) { if (!root || isLeaf(root)) return; if (root.right) { collectBoundaryRight(root.right, res); } else if (root.left) { collectBoundaryRight(root.left, res); } res.push(root.data); } // Function to find Boundary Traversal of Binary Tree function boundaryTraversal(root) { const res = []; if (!root) return res; // Add root data if it's not a leaf if (!isLeaf(root)) { res.push(root.data); } // Collect left boundary collectBoundaryLeft(root.left, res); // Collect leaf nodes collectLeaves(root, res); // Collect right boundary collectBoundaryRight(root.right, res); return res; } //Driver Code Starts{ // Driver code // Hardcoded Binary tree // 20 // / \ // 8 22 // / \ \ // 4 12 25 // / \ // 10 14 const root = new Node(20); root.left = new Node(8); root.right = new Node(22); root.left.left = new Node(4); root.left.right = new Node(12); root.left.right.left = new Node(10); root.left.right.right = new Node(14); root.right.right = new Node(25); const boundary = boundaryTraversal(root); console.log(boundary.join(" ")); //Driver Code Ends } [Approach – 2] Using Iteration and Morris Traversal – O(n) Time and O(1) Space
The idea is to reduce the auxiliary space used by the memory stack in the above approach. This approach is similar to the previous one, but instead of recursion, we use iteration to find the left and right boundaries, and use Morris Traversal to find the leaf nodes.
C++ //Driver Code Starts{ // C++ implementation for Boundary Traversal of Binary Tree // using Iteration with Morris Traversal #include <iostream> #include <vector> using namespace std; class Node { public: int data; Node *left; Node *right; Node(int x) { data = x; left = right = nullptr; } }; //Driver Code Ends } bool isLeaf(Node *node) { return node->left == nullptr && node->right == nullptr; } // Function to collect the left boundary nodes void collectBoundaryLeft(Node *root, vector<int> &res) { if (root == nullptr) return; Node *curr = root; while (!isLeaf(curr)) { res.push_back(curr->data); if (curr->left) curr = curr->left; else curr = curr->right; } } // Function to collect the leaf nodes using Morris Traversal void collectLeaves(Node* root, vector<int>& res) { Node* current = root; while (current) { if (current->left == nullptr) { // If it's a leaf node if (current->right == nullptr) res.push_back(current->data); current = current->right; } else { // Find the inorder predecessor Node* predecessor = current->left; while (predecessor->right && predecessor->right != current) { predecessor = predecessor->right; } if (predecessor->right == nullptr) { predecessor->right = current; current = current->left; } else { // If it's predecessor is a leaf node if (predecessor->left == nullptr) res.push_back(predecessor->data); predecessor->right = nullptr; current = current->right; } } } } // Function to collect the right boundary nodes void collectBoundaryRight(Node *root, vector<int> &res) { if (root == nullptr) return; Node *curr = root; vector<int> temp; while (!isLeaf(curr)) { temp.push_back(curr->data); if (curr->right) curr = curr->right; else curr = curr->left; } for (int i = temp.size() - 1; i >= 0; --i) res.push_back(temp[i]); } // Function to perform boundary traversal vector<int> boundaryTraversal(Node *root) { vector<int> res; if (!root) return res; // Add root data if it's not a leaf if (!isLeaf(root)) res.push_back(root->data); // Collect left boundary collectBoundaryLeft(root->left, res); // Collect leaf nodes collectLeaves(root, res); // Collect right boundary collectBoundaryRight(root->right, res); return res; } //Driver Code Starts{ int main() { // Hardcoded Binary tree // 20 // / \ // 8 22 // / \ \ // 4 12 25 // / \ // 10 14 Node *root = new Node(20); root->left = new Node(8); root->right = new Node(22); root->left->left = new Node(4); root->left->right = new Node(12); root->left->right->left = new Node(10); root->left->right->right = new Node(14); root->right->right = new Node(25); vector<int> boundary = boundaryTraversal(root); for (int x : boundary) cout << x << " "; return 0; } //Driver Code Ends } //Driver Code Starts{ // Java implementation for Boundary Traversal of Binary Tree // using Iteration with Morris Traversal import java.util.ArrayList; class Node { int data; Node left, right; Node(int x) { data = x; left = right = null; } } class GfG { //Driver Code Ends } static boolean isLeaf(Node node) { return node.left == null && node.right == null; } // Function to collect the left boundary nodes static void collectBoundaryLeft(Node root, ArrayList<Integer> res) { if (root == null) return; Node curr = root; while (!isLeaf(curr)) { res.add(curr.data); if (curr.left != null) curr = curr.left; else curr = curr.right; } } // Function to collect the leaf nodes using Morris Traversal static void collectLeaves(Node root, ArrayList<Integer> res) { Node current = root; while (current != null) { if (current.left == null) { // If it's a leaf node if (current.right == null) res.add(current.data); current = current.right; } else { // Find the inorder predecessor Node predecessor = current.left; while (predecessor.right != null && predecessor.right != current) { predecessor = predecessor.right; } if (predecessor.right == null) { predecessor.right = current; current = current.left; } else { // If it's predecessor is a leaf node if (predecessor.left == null) res.add(predecessor.data); predecessor.right = null; current = current.right; } } } } // Function to collect the right boundary nodes static void collectBoundaryRight(Node root, ArrayList<Integer> res) { if (root == null) return; Node curr = root; ArrayList<Integer> temp = new ArrayList<>(); while (!isLeaf(curr)) { temp.add(curr.data); if (curr.right != null) curr = curr.right; else curr = curr.left; } for (int i = temp.size() - 1; i >= 0; --i) res.add(temp.get(i)); } // Function to perform boundary traversal static ArrayList<Integer> boundaryTraversal(Node root) { ArrayList<Integer> res = new ArrayList<>(); if (root == null) return res; // Add root data if it's not a leaf if (!isLeaf(root)) res.add(root.data); // Collect left boundary collectBoundaryLeft(root.left, res); // Collect leaf nodes collectLeaves(root, res); // Collect right boundary collectBoundaryRight(root.right, res); return res; } //Driver Code Starts{ public static void main(String[] args) { // Hardcoded Binary tree // 20 // / \ // 8 22 // / \ \ // 4 12 25 // / \ // 10 14 Node root = new Node(20); root.left = new Node(8); root.right = new Node(22); root.left.left = new Node(4); root.left.right = new Node(12); root.left.right.left = new Node(10); root.left.right.right = new Node(14); root.right.right = new Node(25); ArrayList<Integer> boundary = boundaryTraversal(root); for (int x : boundary) System.out.print(x + " "); } } //Driver Code Ends } #Driver Code Starts{ # Python implementation for Boundary Traversal # of Binary Tree using Iteration with Morris Traversal class Node: def __init__(self, x): self.data = x self.left = None self.right = None #Driver Code Ends } # Helper function to check if a node is a leaf def isLeaf(node): return node.left is None and node.right is None # Function to collect the left boundary nodes def collectBoundaryLeft(root, res): if root is None: return curr = root while not isLeaf(curr): res.append(curr.data) if curr.left: curr = curr.left else: curr = curr.right # Function to collect the leaf nodes using Morris Traversal def collectLeaves(root, res): current = root while current: if current.left is None: # To include Rightmost leaf node if current.right is None: res.append(current.data) current = current.right else: # Find the inorder predecessor predecessor = current.left while predecessor.right and predecessor.right != current: predecessor = predecessor.right if predecessor.right is None: predecessor.right = current current = current.left else: # If it's predecessor is a leaf node if (predecessor.left is None) : res.append(predecessor.data) predecessor.right = None current = current.right # Function to collect the right boundary nodes def collectBoundaryRight(root, res): if root is None: return curr = root temp = [] while not isLeaf(curr): temp.append(curr.data) if curr.right: curr = curr.right else: curr = curr.left res.extend(reversed(temp)) # Function to perform boundary traversal def boundaryTraversal(root): res = [] if not root: return res # Add root data if it's not a leaf if not isLeaf(root): res.append(root.data) # Collect left boundary collectBoundaryLeft(root.left, res) # Collect leaf nodes collectLeaves(root, res) # Collect right boundary collectBoundaryRight(root.right, res) return res #Driver Code Starts{ if __name__ == "__main__": # Hardcoded Binary tree # 20 # / \ # 8 22 # / \ \ # 4 12 25 # / \ # 10 14 root = Node(20) root.left = Node(8) root.right = Node(22) root.left.left = Node(4) root.left.right = Node(12) root.left.right.left = Node(10) root.left.right.right = Node(14) root.right.right = Node(25) boundary = boundaryTraversal(root) print(" ".join(map(str, boundary))) #Driver Code Ends } //Driver Code Starts{ // C# implementation for Boundary Traversal of Binary Tree // using Iteration with Morris Traversal using System; using System.Collections.Generic; class Node { public int data; public Node left, right; public Node(int x) { data = x; left = right = null; } } class GfG { //Driver Code Ends } // Helper function to check if a node is a leaf static bool isLeaf(Node node) { return node.left == null && node.right == null; } // Function to collect the left boundary nodes static void collectBoundaryLeft(Node root, List<int> res) { if (root == null) return; Node curr = root; while (!isLeaf(curr)) { res.Add(curr.data); if (curr.left != null) curr = curr.left; else curr = curr.right; } } // Function to collect the leaf nodes using Morris Traversal static void collectLeaves(Node root, List<int> res) { Node current = root; while (current != null) { if (current.left == null) { // If it's a leaf node if (current.right == null) res.Add(current.data); current = current.right; } else { // Find the inorder predecessor Node predecessor = current.left; while (predecessor.right != null && predecessor.right != current) { predecessor = predecessor.right; } if (predecessor.right == null) { predecessor.right = current; current = current.left; } else { // If it's predecessor is a leaf node if (predecessor.left == null) res.Add(predecessor.data); predecessor.right = null; current = current.right; } } } } // Function to collect the right boundary nodes static void collectBoundaryRight(Node root, List<int> res) { if (root == null) return; Node curr = root; List<int> temp = new List<int>(); while (!isLeaf(curr)) { temp.Add(curr.data); if (curr.right != null) curr = curr.right; else curr = curr.left; } temp.Reverse(); res.AddRange(temp); } // Function to perform boundary traversal static List<int> boundaryTraversal(Node root) { List<int> res = new List<int>(); if (root == null) return res; // Add root data if it's not a leaf if (!isLeaf(root)) res.Add(root.data); // Collect left boundary collectBoundaryLeft(root.left, res); // Collect leaf nodes collectLeaves(root, res); // Collect right boundary collectBoundaryRight(root.right, res); return res; } //Driver Code Starts{ static void Main(string[] args) { // Hardcoded Binary tree // 20 // / \ // 8 22 // / \ \ // 4 12 25 // / \ // 10 14 Node root = new Node(20); root.left = new Node(8); root.right = new Node(22); root.left.left = new Node(4); root.left.right = new Node(12); root.left.right.left = new Node(10); root.left.right.right = new Node(14); root.right.right = new Node(25); List<int> boundary = boundaryTraversal(root); foreach (int x in boundary) { Console.Write(x + " "); } } } //Driver Code Ends } //Driver Code Starts{ // JavaScript implementation for Boundary Traversal // of Binary Tree using Iteration with Morris Traversal class Node { constructor(data) { this.data = data; this.left = null; this.right = null; } //Driver Code Ends } } // Helper function to check if a node is a leaf function isLeaf(node) { return !node.left && !node.right; } // Function to collect the left boundary nodes function collectBoundaryLeft(root, res) { if (root === null) return; let curr = root; while (!isLeaf(curr)) { res.push(curr.data); if (curr.left) curr = curr.left; else curr = curr.right; } } // Function to collect the leaf nodes using Morris Traversal function collectLeaves(root, res) { let current = root; while (current) { if (!current.left) { // If it's a leaf node if (!current.right) res.push(current.data); current = current.right; } else { // Find the inorder predecessor let predecessor = current.left; while (predecessor.right && predecessor.right !== current) { predecessor = predecessor.right; } if (!predecessor.right) { predecessor.right = current; current = current.left; } else { // If it's predecessor is a leaf node if (!predecessor.left) res.push(predecessor.data); predecessor.right = null; current = current.right; } } } } // Function to collect the right boundary nodes function collectBoundaryRight(root, res) { if (root === null) return; let curr = root; const temp = []; while (!isLeaf(curr)) { temp.push(curr.data); if (curr.right) curr = curr.right; else curr = curr.left; } res.push(...temp.reverse()); } // Function to perform boundary traversal function boundaryTraversal(root) { const res = []; if (!root) return res; // Add root data if it's not a leaf if (!isLeaf(root)) res.push(root.data); // Collect left boundary collectBoundaryLeft(root.left, res); // Collect leaf nodes collectLeaves(root, res); // Collect right boundary collectBoundaryRight(root.right, res); return res; } //Driver Code Starts{ // Driver code // Hardcoded Binary tree // 20 // / \ // 8 22 // / \ \ // 4 12 25 // / \ // 10 14 const root = new Node(20); root.left = new Node(8); root.right = new Node(22); root.left.left = new Node(4); root.left.right = new Node(12); root.left.right.left = new Node(10); root.left.right.right = new Node(14); root.right.right = new Node(25); const boundary = boundaryTraversal(root); console.log(boundary.join(" ")); //Driver Code Ends } Similar Reads
Binary Tree Data Structure
A Binary Tree Data Structure is a hierarchical data structure in which each node has at most two children, referred to as the left child and the right child. It is commonly used in computer science for efficient storage and retrieval of data, with various operations such as insertion, deletion, and
3 min read
Introduction to Binary Tree
Binary Tree is a non-linear and hierarchical data structure where each node has at most two children referred to as the left child and the right child. The topmost node in a binary tree is called the root, and the bottom-most nodes are called leaves. Representation of Binary TreeEach node in a Binar
15+ min read
Properties of Binary Tree
This post explores the fundamental properties of a binary tree, covering its structure, characteristics, and key relationships between nodes, edges, height, and levels Note: Height of root node is considered as 0. Properties of Binary Trees1. Maximum Nodes at Level 'l'A binary tree can have at most
4 min read
Applications, Advantages and Disadvantages of Binary Tree
A binary tree is a tree that has at most two children for any of its nodes. There are several types of binary trees. To learn more about them please refer to the article on "Types of binary tree" Applications:General ApplicationsDOM in HTML: Binary trees help manage the hierarchical structure of web
2 min read
Binary Tree (Array implementation)
Given an array that represents a tree in such a way that array indexes are values in tree nodes and array values give the parent node of that particular index (or node). The value of the root node index would always be -1 as there is no parent for root. Construct the standard linked representation o
6 min read
Maximum Depth of Binary Tree
Given a binary tree, the task is to find the maximum depth of the tree. The maximum depth or height of the tree is the number of edges in the tree from the root to the deepest node. Examples: Input: Output: 2Explanation: The longest path from the root (node 12) goes through node 8 to node 5, which h
11 min read
Insertion in a Binary Tree in level order
Given a binary tree and a key, the task is to insert the key into the binary tree at the first position available in level order manner. Examples: Input: key = 12 Output: Explanation: Node with value 12 is inserted into the binary tree at the first position available in level order manner. Approach:
8 min read
Deletion in a Binary Tree
Given a binary tree, the task is to delete a given node from it by making sure that the tree shrinks from the bottom (i.e. the deleted node is replaced by the bottom-most and rightmost node). This is different from BST deletion. Here we do not have any order among elements, so we replace them with t
12 min read
Enumeration of Binary Trees
A Binary Tree is labeled if every node is assigned a label and a Binary Tree is unlabelled if nodes are not assigned any label. Below two are considered same unlabelled trees o o / \ / \ o o o o Below two are considered different labelled trees A C / \ / \ B C A B How many different Unlabelled Binar
3 min read