Boundary Traversal of binary tree - GeeksforGeeks

07 Apr, 2022
Given a binary tree, print boundary nodes of the binary tree Anti-Clockwise starting from the root. The boundary includes left boundary, leaves, and right boundary in order without duplicate nodes. (The values of the nodes may still be duplicates.)The left boundary is defined as the path from the root to the left-most node. The right boundary is defined as the path from the root to the right-most node. If the root doesn’t have left subtree or right subtree, then the root itself is left boundary or right boundary. Note this definition only applies to the input binary tree, and not apply to any subtrees.The left-most node is defined as a leaf node you could reach when you always firstly travel to the left subtree if it exists. If not, travel to the right subtree. Repeat until you reach a leaf node.The right-most node is also defined in the same way with left and right exchanged. For example, boundary traversal of the following tree is “20 8 4 10 14 25 22” 
 
We break the problem in 3 parts: 1. Print the left boundary in top-down manner. 2. Print all leaf nodes from left to right, which can again be sub-divided into two sub-parts: .....2.1 Print all leaf nodes of left sub-tree from left to right. .....2.2 Print all leaf nodes of right subtree from left to right. 3. Print the right boundary in bottom-up manner.We need to take care of one thing that nodes are not printed again. e.g. The left most node is also the leaf node of the tree.Based on the above cases, below is the implementation: 
C++
C
Java
Python3
C#
Javascript
#include <iostream>using namespace std; /* A binary tree node has data, pointer to left childand a pointer to right child */struct Node {    int data;    struct Node *left, *right;}; // Utility function to create a new tree nodeNode* newNode(int data){    Node* temp = new Node;    temp->data = data;    temp->left = temp->right = nullptr;    return temp;} // A simple function to print leaf nodes of a binary treevoid printLeaves(Node* root){    if (root == nullptr)        return;     printLeaves(root->left);     // Print it if it is a leaf node    if (!(root->left) && !(root->right))        cout << root->data << " ";     printLeaves(root->right);} // A function to print all left boundary nodes, except a// leaf node. Print the nodes in TOP DOWN mannervoid printBoundaryLeft(Node* root){    if (root == nullptr)        return;     if (root->left) {         // to ensure top down order, print the node        // before calling itself for left subtree        cout << root->data << " ";        printBoundaryLeft(root->left);    }    else if (root->right) {        cout << root->data << " ";        printBoundaryLeft(root->right);    }    // do nothing if it is a leaf node, this way we avoid    // duplicates in output} // A function to print all right boundary nodes, except a// leaf node Print the nodes in BOTTOM UP mannervoid printBoundaryRight(Node* root){    if (root == nullptr)        return;     if (root->right) {        // to ensure bottom up order, first call for right        // subtree, then print this node        printBoundaryRight(root->right);        cout << root->data << " ";    }    else if (root->left) {        printBoundaryRight(root->left);        cout << root->data << " ";    }    // do nothing if it is a leaf node, this way we avoid    // duplicates in output} // A function to do boundary traversal of a given binary// treevoid printBoundary(Node* root){    if (root == nullptr)        return;     cout << root->data << " ";     // Print the left boundary in top-down manner.    printBoundaryLeft(root->left);     // Print all leaf nodes    printLeaves(root->left);    printLeaves(root->right);     // Print the right boundary in bottom-up manner    printBoundaryRight(root->right);} // Driver program to test above functionsint main(){    // Let us construct the tree given in the above diagram    Node* root = newNode(20);    root->left = newNode(8);    root->left->left = newNode(4);    root->left->right = newNode(12);    root->left->right->left = newNode(10);    root->left->right->right = newNode(14);    root->right = newNode(22);    root->right->right = newNode(25);     printBoundary(root);     return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
/* C program for boundary traversalof a binary tree */ #include <stdio.h>#include <stdlib.h> /* A binary tree node has data, pointer to left childand a pointer to right child */struct node {    int data;    struct node *left, *right;}; // A simple function to print leaf nodes of a binary treevoid printLeaves(struct node* root){    if (root == NULL)        return;     printLeaves(root->left);     // Print it if it is a leaf node    if (!(root->left) && !(root->right))        printf("%d ", root->data);     printLeaves(root->right);} // A function to print all left boundary nodes, except a leaf node.// Print the nodes in TOP DOWN mannervoid printBoundaryLeft(struct node* root){    if (root == NULL)        return;     if (root->left) {         // to ensure top down order, print the node        // before calling itself for left subtree        printf("%d ", root->data);        printBoundaryLeft(root->left);    }    else if (root->right) {        printf("%d ", root->data);        printBoundaryLeft(root->right);    }    // do nothing if it is a leaf node, this way we avoid    // duplicates in output} // A function to print all right boundary nodes, except a leaf node// Print the nodes in BOTTOM UP mannervoid printBoundaryRight(struct node* root){    if (root == NULL)        return;     if (root->right) {        // to ensure bottom up order, first call for right        // subtree, then print this node        printBoundaryRight(root->right);        printf("%d ", root->data);    }    else if (root->left) {        printBoundaryRight(root->left);        printf("%d ", root->data);    }    // do nothing if it is a leaf node, this way we avoid    // duplicates in output} // A function to do boundary traversal of a given binary treevoid printBoundary(struct node* root){    if (root == NULL)        return;     printf("%d ", root->data);     // Print the left boundary in top-down manner.    printBoundaryLeft(root->left);     // Print all leaf nodes    printLeaves(root->left);    printLeaves(root->right);     // Print the right boundary in bottom-up manner    printBoundaryRight(root->right);} // A utility function to create a nodestruct node* newNode(int data){    struct node* temp = (struct node*)malloc(sizeof(struct node));     temp->data = data;    temp->left = temp->right = NULL;     return temp;} // Driver program to test above functionsint main(){    // Let us construct the tree given in the above diagram    struct node* root = newNode(20);    root->left = newNode(8);    root->left->left = newNode(4);    root->left->right = newNode(12);    root->left->right->left = newNode(10);    root->left->right->right = newNode(14);    root->right = newNode(22);    root->right->right = newNode(25);     printBoundary(root);    return 0;}// This code has been contributed by Aditya Kumar (adityakumar129)
// Java program to print boundary traversal of binary tree /* A binary tree node has data, pointer to left childand a pointer to right child */class Node {    int data;    Node left, right;     Node(int item)    {        data = item;        left = right = null;    }} class BinaryTree {    Node root;     // A simple function to print leaf nodes of a binary tree    void printLeaves(Node node)    {        if (node == null)            return;         printLeaves(node.left);        // Print it if it is a leaf node        if (node.left == null && node.right == null)            System.out.print(node.data + " ");        printLeaves(node.right);    }     // A function to print all left boundary nodes, except a leaf node.    // Print the nodes in TOP DOWN manner    void printBoundaryLeft(Node node)    {        if (node == null)            return;         if (node.left != null) {            // to ensure top down order, print the node            // before calling itself for left subtree            System.out.print(node.data + " ");            printBoundaryLeft(node.left);        }        else if (node.right != null) {            System.out.print(node.data + " ");            printBoundaryLeft(node.right);        }         // do nothing if it is a leaf node, this way we avoid        // duplicates in output    }     // A function to print all right boundary nodes, except a leaf node    // Print the nodes in BOTTOM UP manner    void printBoundaryRight(Node node)    {        if (node == null)            return;         if (node.right != null) {            // to ensure bottom up order, first call for right            // subtree, then print this node            printBoundaryRight(node.right);            System.out.print(node.data + " ");        }        else if (node.left != null) {            printBoundaryRight(node.left);            System.out.print(node.data + " ");        }        // do nothing if it is a leaf node, this way we avoid        // duplicates in output    }     // A function to do boundary traversal of a given binary tree    void printBoundary(Node node)    {        if (node == null)            return;         System.out.print(node.data + " ");         // Print the left boundary in top-down manner.        printBoundaryLeft(node.left);         // Print all leaf nodes        printLeaves(node.left);        printLeaves(node.right);         // Print the right boundary in bottom-up manner        printBoundaryRight(node.right);    }     // Driver program to test above functions    public static void main(String args[])    {        BinaryTree tree = new BinaryTree();        tree.root = new Node(20);        tree.root.left = new Node(8);        tree.root.left.left = new Node(4);        tree.root.left.right = new Node(12);        tree.root.left.right.left = new Node(10);        tree.root.left.right.right = new Node(14);        tree.root.right = new Node(22);        tree.root.right.right = new Node(25);        tree.printBoundary(tree.root);    }}
# Python3 program for binary traversal of binary tree # A binary tree nodeclass Node:     # Constructor to create a new node    def __init__(self, data):        self.data = data        self.left = None        self.right = None # A simple function to print leaf nodes of a Binary Treedef printLeaves(root):    if(root):        printLeaves(root.left)                 # Print it if it is a leaf node        if root.left is None and root.right is None:            print(root.data),         printLeaves(root.right) # A function to print all left boundary nodes, except a# leaf node. Print the nodes in TOP DOWN mannerdef printBoundaryLeft(root):         if(root):        if (root.left):                         # to ensure top down order, print the node            # before calling itself for left subtree            print(root.data)            printBoundaryLeft(root.left)                 elif(root.right):            print (root.data)            printBoundaryLeft(root.right)                 # do nothing if it is a leaf node, this way we        # avoid duplicates in output  # A function to print all right boundary nodes, except# a leaf node. Print the nodes in BOTTOM UP mannerdef printBoundaryRight(root):         if(root):        if (root.right):            # to ensure bottom up order, first call for            # right subtree, then print this node            printBoundaryRight(root.right)            print(root.data)                 elif(root.left):            printBoundaryRight(root.left)            print(root.data)         # do nothing if it is a leaf node, this way we        # avoid duplicates in output  # A function to do boundary traversal of a given binary treedef printBoundary(root):    if (root):        print(root.data)                 # Print the left boundary in top-down manner        printBoundaryLeft(root.left)         # Print all leaf nodes        printLeaves(root.left)        printLeaves(root.right)         # Print the right boundary in bottom-up manner        printBoundaryRight(root.right)  # Driver program to test above functionroot = Node(20)root.left = Node(8)root.left.left = Node(4)root.left.right = Node(12)root.left.right.left = Node(10)root.left.right.right = Node(14)root.right = Node(22)root.right.right = Node(25)printBoundary(root) # This code is contributed by# Nikhil Kumar Singh(nickzuck_007)
// C# program to print boundary traversal// of binary treeusing System; /* A binary tree node has data,pointer to left child and a pointerto right child */public class Node {    public int data;    public Node left, right;     public Node(int item)    {        data = item;        left = right = null;    }} class GFG {    public Node root;     // A simple function to print leaf    // nodes of a binary tree    public virtual void printLeaves(Node node)    {        if (node == null)            return;         printLeaves(node.left);         // Print it if it is a leaf node        if (node.left == null && node.right == null) {            Console.Write(node.data + " ");        }        printLeaves(node.right);    }     // A function to print all left boundary    // nodes, except a leaf node. Print the    // nodes in TOP DOWN manner    public virtual void printBoundaryLeft(Node node)    {        if (node == null)            return;         if (node.left != null) {             // to ensure top down order, print the node            // before calling itself for left subtree            Console.Write(node.data + " ");            printBoundaryLeft(node.left);        }        else if (node.right != null) {            Console.Write(node.data + " ");            printBoundaryLeft(node.right);        }         // do nothing if it is a leaf node,        // this way we avoid duplicates in output    }     // A function to print all right boundary    // nodes, except a leaf node. Print the    // nodes in BOTTOM UP manner    public virtual void printBoundaryRight(Node node)    {        if (node == null)            return;         if (node.right != null) {            // to ensure bottom up order,            // first call for right subtree,            // then print this node            printBoundaryRight(node.right);            Console.Write(node.data + " ");        }        else if (node.left != null) {            printBoundaryRight(node.left);            Console.Write(node.data + " ");        }        // do nothing if it is a leaf node,        // this way we avoid duplicates in output    }     // A function to do boundary traversal    // of a given binary tree    public virtual void printBoundary(Node node)    {        if (node == null)            return;         Console.Write(node.data + " ");         // Print the left boundary in        // top-down manner.        printBoundaryLeft(node.left);         // Print all leaf nodes        printLeaves(node.left);        printLeaves(node.right);         // Print the right boundary in        // bottom-up manner        printBoundaryRight(node.right);    }     // Driver Code    public static void Main(string[] args)    {        GFG tree = new GFG();        tree.root = new Node(20);        tree.root.left = new Node(8);        tree.root.left.left = new Node(4);        tree.root.left.right = new Node(12);        tree.root.left.right.left = new Node(10);        tree.root.left.right.right = new Node(14);        tree.root.right = new Node(22);        tree.root.right.right = new Node(25);        tree.printBoundary(tree.root);    }} // This code is contributed by Shrikant13
<script>         // JavaScript program to print boundary    // traversal of binary tree         class Node    {        constructor(item) {           this.left = null;           this.right = null;           this.data = item;        }    }         let root;       // A simple function to print leaf nodes of a binary tree    function printLeaves(node)    {        if (node == null)            return;           printLeaves(node.left);        // Print it if it is a leaf node        if (node.left == null && node.right == null)            document.write(node.data + " ");        printLeaves(node.right);    }       // A function to print all left boundary nodes,    // except a leaf node.    // Print the nodes in TOP DOWN manner    function printBoundaryLeft(node)    {        if (node == null)            return;           if (node.left != null) {            // to ensure top down order, print the node            // before calling itself for left subtree            document.write(node.data + " ");            printBoundaryLeft(node.left);        }        else if (node.right != null) {            document.write(node.data + " ");            printBoundaryLeft(node.right);        }           // do nothing if it is a leaf node, this way we avoid        // duplicates in output    }       // A function to print all right boundary nodes,    // except a leaf node    // Print the nodes in BOTTOM UP manner    function printBoundaryRight(node)    {        if (node == null)            return;           if (node.right != null) {            // to ensure bottom up order, first call for right            // subtree, then print this node            printBoundaryRight(node.right);            document.write(node.data + " ");        }        else if (node.left != null) {            printBoundaryRight(node.left);            document.write(node.data + " ");        }        // do nothing if it is a leaf node, this way we avoid        // duplicates in output    }       // A function to do boundary traversal of a given binary tree    function printBoundary(node)    {        if (node == null)            return;           document.write(node.data + " ");           // Print the left boundary in top-down manner.        printBoundaryLeft(node.left);           // Print all leaf nodes        printLeaves(node.left);        printLeaves(node.right);           // Print the right boundary in bottom-up manner        printBoundaryRight(node.right);    }         root = new Node(20);    root.left = new Node(8);    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 = new Node(22);    root.right.right = new Node(25);    printBoundary(root);   </script>
20 8 4 10 14 25 22 
Time Complexity: O(n) where n is the number of nodes in binary tree.
Auxiliary Space: O(n) 
YouTubeGeeksforGeeks502K subscribersBoundary Traversal of binary tree | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 5:37•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=7yFf4nKsamU" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above 
Ravi Teja Chowdary
joshiyogesh
shrikanth13
Akanksha_Rai
Sanjiban Bairagya
gp6
decode2207
prasanna1995
adityakumar129
Accolite
Amazon
Hike
Kritikal Solutions
Microsoft
Morgan Stanley
Payu
Snapdeal
Tree
Morgan Stanley
Accolite
Amazon
Microsoft
Snapdeal
Hike
Payu
Kritikal Solutions
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Tree Traversals (Inorder, Preorder and Postorder)
Binary Tree | Set 1 (Introduction)
Level Order Binary Tree Traversal
AVL Tree | Set 1 (Insertion)
Inorder Tree Traversal without Recursion
Write a Program to Find the Maximum Depth or Height of a Tree
Binary Tree | Set 3 (Types of Binary Tree)
Binary Tree | Set 2 (Properties)
Decision Tree
A program to check if a binary tree is BST or not