BoundaryTraversal.java

package com.thealgorithms.datastructures.trees;

import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;

/**
 * BoundaryTraversal
 * <p>
 * Start with the Root:
 * Add the root node to the boundary list.
 * Traverse the Left Boundary (Excluding Leaf Nodes):
 * Move down the left side of the tree, adding each non-leaf node to the boundary list.
 * If a node has a left child, go left; otherwise, go right.
 * Visit All Leaf Nodes:
 * Traverse the tree and add all leaf nodes to the boundary list, from left to right.
 * Traverse the Right Boundary (Excluding Leaf Nodes) in Reverse Order:
 * Move up the right side of the tree, adding each non-leaf node to a temporary list.
 * If a node has a right child, go right; otherwise, go left.
 * Reverse the temporary list and add it to the boundary list.
 * Combine and Output:
 * The final boundary list contains the root, left boundary, leaf nodes, and reversed right boundary in that order.
 */
public final class BoundaryTraversal {
    private BoundaryTraversal() {
    }

    // Main function for boundary traversal, returns a list of boundary nodes in order
    public static List<Integer> boundaryTraversal(BinaryTree.Node root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }

        // Add root node if it's not a leaf node
        if (!isLeaf(root)) {
            result.add(root.data);
        }

        // Add left boundary
        addLeftBoundary(root, result);

        // Add leaf nodes
        addLeaves(root, result);

        // Add right boundary
        addRightBoundary(root, result);

        return result;
    }

    // Adds the left boundary, including nodes that have no left child but have a right child
    private static void addLeftBoundary(BinaryTree.Node node, List<Integer> result) {
        BinaryTree.Node cur = node.left;

        // If there is no left child but there is a right child, treat the right child as part of the left boundary
        if (cur == null && node.right != null) {
            cur = node.right;
        }

        while (cur != null) {
            if (!isLeaf(cur)) {
                result.add(cur.data); // Add non-leaf nodes to result
            }
            if (cur.left != null) {
                cur = cur.left; // Move to the left child
            } else if (cur.right != null) {
                cur = cur.right; // If left child is null, move to the right child
            } else {
                break; // Stop if there are no children
            }
        }
    }

    // Adds leaf nodes (nodes without children)
    private static void addLeaves(BinaryTree.Node node, List<Integer> result) {
        if (node == null) {
            return;
        }
        if (isLeaf(node)) {
            result.add(node.data); // Add leaf node
        } else {
            addLeaves(node.left, result); // Recur for left subtree
            addLeaves(node.right, result); // Recur for right subtree
        }
    }

    // Adds the right boundary, excluding leaf nodes
    private static void addRightBoundary(BinaryTree.Node node, List<Integer> result) {
        BinaryTree.Node cur = node.right;
        List<Integer> temp = new ArrayList<>();

        // If no right boundary is present and there is no left subtree, skip
        if (cur != null && node.left == null) {
            return;
        }
        while (cur != null) {
            if (!isLeaf(cur)) {
                temp.add(cur.data); // Store non-leaf nodes temporarily
            }
            if (cur.right != null) {
                cur = cur.right; // Move to the right child
            } else if (cur.left != null) {
                cur = cur.left; // If right child is null, move to the left child
            } else {
                break; // Stop if there are no children
            }
        }

        // Add the right boundary nodes in reverse order
        for (int i = temp.size() - 1; i >= 0; i--) {
            result.add(temp.get(i));
        }
    }

    // Checks if a node is a leaf node
    private static boolean isLeaf(BinaryTree.Node node) {
        return node.left == null && node.right == null;
    }

    // Iterative boundary traversal
    public static List<Integer> iterativeBoundaryTraversal(BinaryTree.Node root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }

        // Add root node if it's not a leaf node
        if (!isLeaf(root)) {
            result.add(root.data);
        }

        // Handle the left boundary
        BinaryTree.Node cur = root.left;
        if (cur == null && root.right != null) {
            cur = root.right;
        }
        while (cur != null) {
            if (!isLeaf(cur)) {
                result.add(cur.data); // Add non-leaf nodes to result
            }
            cur = (cur.left != null) ? cur.left : cur.right; // Prioritize left child, move to right if left is null
        }

        // Add leaf nodes
        addLeaves(root, result);

        // Handle the right boundary using a stack (reverse order)
        cur = root.right;
        Deque<Integer> stack = new LinkedList<>();
        if (cur != null && root.left == null) {
            return result;
        }
        while (cur != null) {
            if (!isLeaf(cur)) {
                stack.push(cur.data); // Temporarily store right boundary nodes in a stack
            }
            cur = (cur.right != null) ? cur.right : cur.left; // Prioritize right child, move to left if right is null
        }

        // Add the right boundary nodes from the stack to maintain the correct order
        while (!stack.isEmpty()) {
            result.add(stack.pop());
        }
        return result;
    }
}