Open In App

Boundary Traversal of binary tree

Last Updated : 08 Feb, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

Given a binary tree, the task is to find the boundary nodes of the binary tree Anti-Clockwise starting from the root.

Boundary-Traversal-of-Binary-Tree--banner

The boundary includes:

  1. left boundary (nodes on left excluding leaf nodes)
  2. leaves (consist of only the leaf nodes)
  3. 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. 

Table of Content

[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
Java 
//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
Python 
#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
C# 
//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
JavaScript 
//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

Output
20 8 4 10 14 25 22

[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
Java 
//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
Python 
#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
C# 
//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
JavaScript 
//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

Output
20 8 4 10 14 25 22

Next Article
Boundary Traversal of binary tree

K
kartik
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox