Leaf nodes from Preorder of a Binary Search Tree (Using Recursion)

Last Updated : 10 Oct, 2024

Given Preorder traversal of a Binary Search Tree. Then the task is to print leaf nodes of the Binary Search Tree from the given preorder.

Examples :

Input : preorder[] = {890, 325, 290, 530, 965};
Output : 290 530 965
Explanation: Below is the representation of BST using preorder array.

Approach:

To identify leaf nodes from a given preorder traversal of a binary search tree (BST), we employ a recursive approach that utilizes the properties of BSTs and preorder traversal. The algorithm maintains two variables, min and max, which define the valid range for each node based on its position in the tree. Starting with an index i set to zero, we traverse the preorder array. For each node, we check if its value lies within the specified range. if so, we consider it a valid node. We then increment the index and make recursive calls to check for potential left and right children, adjusting the min and max values accordingly. If both recursive calls return false, indicating that the node has no children, we store the node’s value as it is a leaf.

Below is the implementation of the above approach:

C++

// Recursive C++ program  to find leaf 
// nodes from given preorder traversal

#include<bits/stdc++.h>
using namespace std;

// Print the leaf node from 
// the given preorder of BST.
bool isLeaf(vector<int> pre, int &i, int n, int min, int max) {
  	
  	// If all elements is checked return  
  	if (i >= n) 
        return false;
    
  	// Check if node is leaf or not
    if (pre[i] > min && pre[i] < max) {
        i++;
        
      	// Left and right node status if both are false
      	// then current node is leaf node
        bool left = isLeaf(pre, i, n, min, pre[i-1]);
        bool right = isLeaf(pre, i, n, pre[i-1], max);
        
      	// if no node found at left and right side print data
        if (!left && !right) 
            cout << pre[i-1] << " ";
            
        return true;
    }
    return false;
}

// Function to print all leafs
void printLeaves(vector<int> preorder,  int n) {
    int i = 0;    
  
    isLeaf(preorder, i, n, INT_MIN, INT_MAX);
}


int main() {
  	int n = 5;
	
  	// Array represantion of below BST
  	//        10
  	//       /  \ 
    //      6    13
    //     / \
  	//    2   7
  	vector<int> preorder{10, 6, 2, 7, 13};
    printLeaves(preorder, n);    
    return 0;
}

// Recursive C program to find leaf 
// nodes from given preorder traversal

#include <stdio.h>
#include <limits.h>

// Print the leaf node from 
// the given preorder of BST.
int isLeaf(int pre[], int *i, int n, int min, int max) {
    
    // If all elements are checked return  
    if (*i >= n)
        return 0;

    // Check if node is leaf or not
    if (pre[*i] > min && pre[*i] < max) {
        (*i)++;

        // Left and right node status, if both are false
        // then current node is leaf node
        int left = isLeaf(pre, i, n, min, pre[*i - 1]);
        int right = isLeaf(pre, i, n, pre[*i - 1], max);

        // if no node found at left and right side print data
        if (!left && !right)
            printf("%d ", pre[*i - 1]);

        return 1;
    }
    return 0;
}

// Function to print all leaves
void printLeaves(int preorder[], int n) {
    int i = 0;

    isLeaf(preorder, &i, n, INT_MIN, INT_MAX);
}

int main() {
    int n = 5;
    
    // Array representation of below BST
    //        10
    //       /  \ 
    //      6    13
    //     / \
    //    2   7
    int preorder[] = {10, 6, 2, 7, 13};
    printLeaves(preorder, n);
    return 0;
}

Java

// Recursive Java program to find leaf 
// nodes from given preorder traversal

import java.util.*;

class GfG {

    // Print the leaf node from 
    // the given preorder of BST.
    static boolean isLeaf(List<Integer> pre, int[] i, int n, int min, int max) {
        
        // If all elements is checked return  
        if (i[0] >= n)
            return false;

        // Check if node is leaf or not
        if (pre.get(i[0]) > min && pre.get(i[0]) < max) {
            i[0]++;
            
            // Left and right node status if both are false
            // then current node is leaf node
            boolean left = isLeaf(pre, i, n, min, pre.get(i[0] - 1));
            boolean right = isLeaf(pre, i, n, pre.get(i[0] - 1), max);

            // if no node found at left and right side print data
            if (!left && !right)
                System.out.print(pre.get(i[0] - 1) + " ");

            return true;
        }
        return false;
    }

    // Function to print all leaves
    static void printLeaves(List<Integer> preorder, int n) {
        int[] i = {0};

        // Call utility function to print all leaves
        isLeaf(preorder, i, n, Integer.MIN_VALUE, Integer.MAX_VALUE);
    }

    public static void main(String[] args) {
        int n = 5;
        
        // Array representation of below BST
        //        10
        //       /  \ 
        //      6    13
        //     / \
        //    2   7
        List<Integer> preorder = Arrays.asList(10, 6, 2, 7, 13);
        printLeaves(preorder, n);
    }
}

Python

# Recursive Python program to find leaf 
# nodes from given preorder traversal

# Print the leaf node from 
# the given preorder of BST.
def is_leaf(pre, i, n, min_val, max_val):
    
    # If all elements is checked return  
    if i[0] >= n:
        return False

    # Check if node is leaf or not
    if min_val < pre[i[0]] < max_val:
        i[0] += 1
        
        # Left and right node status if both are false
        # then current node is leaf node
        left = is_leaf(pre, i, n, min_val, pre[i[0] - 1])
        right = is_leaf(pre, i, n, pre[i[0] - 1], max_val)

        # if no node found at left and right side print data
        if not left and not right:
            print(pre[i[0] - 1], end=" ")

        return True
    return False

# Function to print all leaves
def print_leaves(preorder, n):
    i = [0]
    
    # Call utility function to print all leaves
    is_leaf(preorder, i, n, float('-inf'), float('inf'))


if __name__ == "__main__":
    n = 5
    
    # Array representation of below BST
    #        10
    #       /  \ 
    #      6    13
    #     / \
    #    2   7
    preorder = [10, 6, 2, 7, 13]
    print_leaves(preorder, n)

// Recursive C# program to find leaf 
// nodes from given preorder traversal

using System;
using System.Collections.Generic;

class GfG {

    // Print the leaf node from 
    // the given preorder of BST.
    static bool IsLeaf(List<int> pre, ref int i, int n, 
                       int min, int max) {

        // If all elements is checked return  
        if (i >= n) 
            return false;

        // Check if node is leaf or not
        if (pre[i] > min && pre[i] < max) {
            i++;
            
            // Left and right node status if both are false
            // then current node is leaf node
            bool left = IsLeaf(pre, ref i, n, min, pre[i - 1]);
            bool right = IsLeaf(pre, ref i, n, pre[i - 1], max);

            // if no node found at left and right side print data
            if (!left && !right)
                Console.Write(pre[i - 1] + " ");

            return true;
        }
        return false;
    }

    // Function to print all leaves
    static void PrintLeaves(List<int> preorder, int n) {
        int i = 0;
        
        IsLeaf(preorder, ref i, n, int.MinValue, int.MaxValue);
    }

    static void Main() {
        int n = 5;
        
        // Array representation of below BST
        //        10
        //       /  \ 
        //      6    13
        //     / \
        //    2   7
        List<int> preorder = new List<int> { 10, 6, 2, 7, 13 };
        PrintLeaves(preorder, n);
    }
}

JavaScript

// Recursive JavaScript program to find leaf 
// nodes from given preorder traversal

// Print the leaf node from 
// the given preorder of BST.
function isLeaf(pre, i, n, min, max) {
  
    // If all elements is checked return  
    if (i[0] >= n)
        return false;

    // Check if node is leaf or not
    if (pre[i[0]] > min && pre[i[0]] < max) {
        i[0]++;
        
        // Left and right node status if both are false
        // then current node is leaf node
        let left = isLeaf(pre, i, n, min, pre[i[0] - 1]);
        let right = isLeaf(pre, i, n, pre[i[0] - 1], max);

        // if no node found at left and right side print data
        if (!left && !right)
            console.log(pre[i[0] - 1]);

        return true;
    }
    return false;
}

// Function to print all leaves
function printLeaves(preorder, n) {
    let i = [0];
    
    isLeaf(preorder, i, n, Number.MIN_SAFE_INTEGER, 
    					Number.MAX_SAFE_INTEGER);
}

let n = 5;

// Array representation of below BST
//        10
//       /  \ 
//      6    13
//     / \
//    2   7
let preorder = [10, 6, 2, 7, 13];
printLeaves(preorder, n);

Output

2 7 13

Time Complexity: O(n), As we are traversing the BST only once.
Auxiliary Space: O(h), here h is the height of the BST and the extra space is used in the recursion call stack.

Related article:

Leaf nodes from Preorder of a Binary Search Tree

Analysis of Algorithms

vishal22091998

Improve

Article Tags :

Practice Tags :

Leaf nodes from Preorder of a Binary Search Tree (Using Recursion)

Similar Reads

Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?