Leaf nodes from Preorder of a Binary Search Tree (Using Recursion)
Last Updated :
30 Nov, 2022
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
Tree represented is,
890
/ \
325 965
/ \
290 530
Input : preorder[] = { 3, 2, 4 };
Output : 2 4
In this post, a simple recursive solution is discussed. The idea is to use two min and max variables and taking i (index in input array), the index for given preorder array, and recursively creating root node and correspondingly checking if left and right are existing or not. This method returns boolean variable, and if both left and right are false it simply means that left and right are null hence it must be a leaf node so print it right there and return back true as root at that index existed.
Implementation:
C++
#include<bits/stdc++.h>
using namespace std;
bool isLeaf(int pre[], int &i, int n,
int min, int max)
{
if (i >= n)
return false;
if (pre[i] > min && pre[i] < max) {
i++;
bool left = isLeaf(pre, i, n, min, pre[i-1]);
bool right = isLeaf(pre, i, n, pre[i-1], max);
if (!left && !right)
cout << pre[i-1] << " ";
return true;
}
return false;
}
void printLeaves(int preorder[], int n)
{
int i = 0;
isLeaf(preorder, i, n, INT_MIN, INT_MAX);
}
int main()
{
int preorder[] = { 890, 325, 290, 530, 965 };
int n = sizeof(preorder)/sizeof(preorder[0]);
printLeaves(preorder, n);
return 0;
}
|
Java
class GFG
{
static int i = 0;
static boolean isLeaf(int pre[], int n,
int min, int max)
{
if (i >= n)
{
return false;
}
if (pre[i] > min && pre[i] < max)
{
i++;
boolean left = isLeaf(pre, n, min, pre[i - 1]);
boolean right = isLeaf(pre, n, pre[i - 1], max);
if (!left && !right)
{
System.out.print(pre[i - 1] + " ");
}
return true;
}
return false;
}
static void printLeaves(int preorder[], int n)
{
isLeaf(preorder, n, Integer.MIN_VALUE,
Integer.MAX_VALUE);
}
public static void main(String[] args)
{
int preorder[] = {890, 325, 290, 530, 965};
int n = preorder.length;
printLeaves(preorder, n);
}
}
|
Python3
def isLeaf(pre, i, n, Min, Max):
if i[0] >= n:
return False
if pre[i[0]] > Min and pre[i[0]] < Max:
i[0] += 1
left = isLeaf(pre, i, n, Min,
pre[i[0] - 1])
right = isLeaf(pre, i, n,
pre[i[0] - 1], Max)
if left == False and right == False:
print(pre[i[0] - 1], end = " ")
return True
return False
def printLeaves(preorder, n):
i = [0]
INT_MIN, INT_MAX = -999999999999, 999999999999
isLeaf(preorder, i, n, INT_MIN, INT_MAX)
if __name__ == '__main__':
preorder = [890, 325, 290, 530, 965]
n = len(preorder)
printLeaves(preorder, n)
|
C#
using System;
class GFG
{
static int i = 0;
static bool isLeaf(int []pre, int n,
int min, int max)
{
if (i >= n)
{
return false;
}
if (pre[i] > min && pre[i] < max)
{
i++;
bool left = isLeaf(pre, n, min, pre[i - 1]);
bool right = isLeaf(pre, n, pre[i - 1], max);
if (!left && !right)
{
Console.Write(pre[i - 1] + " ");
}
return true;
}
return false;
}
static void printLeaves(int []preorder, int n)
{
isLeaf(preorder, n, int.MinValue, int.MaxValue);
}
public static void Main(String[] args)
{
int []preorder = {890, 325, 290, 530, 965};
int n = preorder.Length;
printLeaves(preorder, n);
}
}
|
PHP
<?php
function isLeaf($pre, &$i, $n,
$min, $max)
{
if ($i >= $n)
return false;
if ($pre[$i] > $min &&
$pre[$i] < $max)
{
$i++;
$left = isLeaf($pre, $i, $n,
$min, $pre[$i - 1]);
$right = isLeaf($pre, $i, $n,
$pre[$i - 1], $max);
if (!$left && !$right)
echo $pre[$i - 1] , " ";
return true;
}
return false;
}
function printLeaves($preorder, $n)
{
$i = 0;
isLeaf($preorder, $i, $n,
PHP_INT_MIN, PHP_INT_MAX);
}
$preorder = array (890, 325, 290,
530, 965 );
$n = sizeof($preorder);
printLeaves($preorder, $n);
?>
|
Javascript
<script>
let i = 0;
function isLeaf(pre, n, min, max)
{
if (i >= n)
{
return false;
}
if (pre[i] > min && pre[i] < max)
{
i++;
let left = isLeaf(pre, n, min, pre[i - 1]);
let right = isLeaf(pre, n, pre[i - 1], max);
if (!left && !right)
{
document.write(pre[i - 1] + " ");
}
return true;
}
return false;
}
function printLeaves(preorder, n)
{
isLeaf(preorder, n, Number.MIN_VALUE,
Number.MAX_VALUE);
}
let preorder = [ 890, 325, 290, 530, 965 ];
let n = preorder.length;
printLeaves(preorder, n);
</script>
|
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.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...