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. Introduction to Binary TreeRepresentation of Bina
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 levelsBinary tree representationNote: Height of root node is considered as 0. Properties of Binary Trees1. Maximum Nodes at Level 'l'A bina
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 has
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:The
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