Boundary Traversal of Binary Tree in DSA Javascript - Build from Scratch

Boundary Traversal of Binary Tree

📖 Scenario: You are working with a binary tree data structure that represents a hierarchy of tasks in a project. You want to collect the tasks that lie on the boundary of this tree to review the outermost tasks first.

🎯 Goal: Build a program that performs a boundary traversal of a binary tree. The boundary traversal visits the nodes on the left boundary (top to bottom), then all leaf nodes (left to right), and finally the nodes on the right boundary (bottom to top).

📋 What You'll Learn

Create a binary tree with the exact structure given.

Add a helper variable to store the boundary nodes.

Implement the boundary traversal logic using functions and loops.

Print the boundary traversal result as a list of node values.

💡 Why This Matters

🌍 Real World

Boundary traversal helps in scenarios where you want to process or review the outermost elements of hierarchical data, such as project tasks, organizational charts, or file systems.

💼 Career

Understanding tree traversals and boundary traversal is useful for software engineers working with hierarchical data structures, UI trees, and algorithms that require selective node processing.

1

Create the Binary Tree Structure

Create a binary tree using the Node class with this exact structure:
root node with value 20,
left child 8, right child 22,
left child of 8 is 4, right child of 8 is 12,
left child of 12 is 10, right child of 12 is 14,
right child of 22 is 25.

DSA Javascript

// Define Node class and create the binary tree nodes
// Your code here

Hint

Use a class called Node with data, left, and right properties. Create nodes and link them exactly as described.

2

Create an Array to Store Boundary Nodes

Create an empty array called boundaryNodes to store the boundary traversal nodes.

DSA Javascript

class Node {
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

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);

// Create an empty array to store boundary nodes
// Your code here

Hint

Use const boundaryNodes = []; to create an empty array.

3

Implement Boundary Traversal Logic

Write functions isLeaf(node), addLeftBoundary(node), addLeaves(node), and addRightBoundary(node) to collect boundary nodes. Then call these functions in order to fill boundaryNodes with the boundary traversal of the tree starting from root.

DSA Javascript

class Node {
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

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 boundaryNodes = [];

// Write functions isLeaf, addLeftBoundary, addLeaves, addRightBoundary
// Then call them to fill boundaryNodes
// Your code here

Hint

Use helper functions to add left boundary, leaves, and right boundary nodes. Add root first if it is not a leaf.

4

Print the Boundary Traversal Result

Print the boundaryNodes array to display the boundary traversal of the binary tree.

DSA Javascript

class Node {
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

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 boundaryNodes = [];

function isLeaf(node) {
    return node.left === null && node.right === null;
}

function addLeftBoundary(node) {
    let curr = node.left;
    while (curr) {
        if (!isLeaf(curr)) boundaryNodes.push(curr.data);
        if (curr.left) curr = curr.left;
        else curr = curr.right;
    }
}

function addLeaves(node) {
    if (isLeaf(node)) {
        boundaryNodes.push(node.data);
        return;
    }
    if (node.left) addLeaves(node.left);
    if (node.right) addLeaves(node.right);
}

function addRightBoundary(node) {
    let curr = node.right;
    const temp = [];
    while (curr) {
        if (!isLeaf(curr)) temp.push(curr.data);
        if (curr.right) curr = curr.right;
        else curr = curr.left;
    }
    for (let i = temp.length - 1; i >= 0; i--) {
        boundaryNodes.push(temp[i]);
    }
}

if (root) {
    if (!isLeaf(root)) boundaryNodes.push(root.data);
    addLeftBoundary(root);
    addLeaves(root);
    addRightBoundary(root);
}

// Print the boundaryNodes array
// Your code here

Hint

Use console.log(boundaryNodes); to print the final boundary traversal array.