二叉搜索树的预排序中的叶节点(使用递归)

给定二元搜索树的遍历。然后，任务是从给定的预定顺序中搜索二叉搜索树的叶子节点。

例子 ：

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

在这篇文章中，讨论了一个简单的递归解决方案。这个想法是使用两个最小和最大变量，并取i(输入数组的索引)，给定预排序数组的索引，然后递归创建根节点，并相应地检查左和右是否存在。此方法返回布尔变量，如果left和right均为false，则仅表示left和right为null，因此它必须是叶节点，因此请在该节点上打印它，并在存在该索引的根节点处返回true。

C++

// Recursive C++ program  to find leaf 
// nodes from given preorder traversal
#include
using namespace std;
  
// Print the leaf node from 
// the given preorder of BST.
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);
}
  
// Driver code
int main()
{
    int preorder[] = { 890, 325, 290, 530, 965 };
    int n = sizeof(preorder)/sizeof(preorder[0]);
    printLeaves(preorder, n);    
    return 0;
}

Java

// Recursive Java program to find leaf 
// nodes from given preorder traversal
class GFG 
{
  
    static int i = 0;
  
    // Print the leaf node from 
    // the given preorder of BST.
    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);
    }
  
    // Driver code
    public static void main(String[] args) 
    {
        int preorder[] = {890, 325, 290, 530, 965};
        int n = preorder.length;
        printLeaves(preorder, n);
    }
}
  
// This code contributed by Rajput-Ji

Python3

# Recursive Python program to find leaf 
# nodes from given preorder traversal 
  
# Print the leaf node from 
# the given preorder of BST. 
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)
  
# Driver code 
if __name__ == '__main__':
    preorder = [890, 325, 290, 530, 965] 
    n = len(preorder) 
    printLeaves(preorder, n)
      
# This code is contributed by PranchalK

C#

// Recursive C# program to find leaf 
// nodes from given preorder traversal 
using System;
  
class GFG 
{ 
  
    static int i = 0; 
  
    // Print the leaf node from 
    // the given preorder of BST. 
    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); 
    } 
  
    // Driver code 
    public static void Main(String[] args) 
    { 
        int []preorder = {890, 325, 290, 530, 965}; 
        int n = preorder.Length; 
        printLeaves(preorder, n); 
    } 
} 
  
// This code is contributed by princiraj1992

PHP

= $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);
}
  
// Driver code
$preorder = array (890, 325, 290, 
                   530, 965 );
$n = sizeof($preorder);
printLeaves($preorder, $n); 
  
// This code is contributed by ajit
?>

输出 ：

290 530 965