Leaf nodes from Preorder of a Binary Search Tree

// C++ program to print leaf node from preorder of
// binary search tree using inorder + preorder
#include <bits/stdc++.h>
using namespace std;

int binarySearch(vector<int>& inorder, int l,
                                       int r, int d) {
    int mid = (l + r) >> 1;

    if (inorder[mid] == d)
        return mid;

    else if (inorder[mid] > d)
        return binarySearch(inorder, l, mid - 1, d);

    else
        return binarySearch(inorder, mid + 1, r, d);
}

// Function to find Leaf Nodes by doing preorder
// traversal of tree using preorder and inorder vectors.
void leafNodesRec(vector<int>& preorder, vector<int>& inorder,
                  int l, int r, int& ind, vector<int>& leaves) {
  
    // If l == r, therefore no right or left subtree.
    // So, it must be leaf Node, store it.
    if (l == r) {
        leaves.push_back(inorder[l]);
        ind++;
        return;
    }

    // If array is out of bound, return.
    if (l < 0 || l > r || r >= inorder.size())
        return;

    // Finding the index of preorder element
    // in inorder vector using binary search.
    int loc = binarySearch(inorder, l, r, preorder[ind]);

    ind++;

    // Finding on the left subtree.
    leafNodesRec(preorder, inorder, l, loc - 1, 
                                          ind, leaves);

    // Finding on the right subtree.
    leafNodesRec(preorder, inorder, loc + 1, r,
                                          ind, leaves);
}

// Finds leaf nodes from given preorder traversal.
vector<int> leafNodes(vector<int>& preorder) {
    int n = preorder.size();
    vector<int> inorder(n);  
    vector<int> leaves;      
  
    // Copy the preorder into another vector.
    for (int i = 0; i < n; i++)
        inorder[i] = preorder[i];

    // Finding the inorder by sorting the vector.
    sort(inorder.begin(), inorder.end());

    // Point to the index in preorder.
    int ind = 0;

    // Find the Leaf Nodes.
    leafNodesRec(preorder, inorder, 0, n - 1,
                                      ind, leaves);
    return leaves;
}


int main() {
  
    vector<int> preorder = {4, 2, 1, 3, 6, 5};
    
    vector<int> result = leafNodes(preorder);

	for (int val : result) {
        cout << val << " ";
    }
  
    return 0;
}

// C++ program to print leaf nodes from the preorder 
// traversal of a Binary Search Tree using a stack
#include <iostream>
#include <stack>
#include <vector>

using namespace std;

// Function to find leaf nodes from the 
// preorder traversal
vector<int> leafNodes(vector<int>& preorder) {
    stack<int> s; 
    vector<int> leaves;
    int n = preorder.size();

    // Iterate through the preorder vector
    for (int i = 0, j = 1; j < n; i++, j++) {
        bool found = false;

        // Push current node if it's greater than 
        // the next node
        if (preorder[i] > preorder[j]) {
            s.push(preorder[i]);
        } 
        else {
          
            // Pop elements from stack until current node is 
            // less than or equal to top of stack
            while (!s.empty()) {
                if (preorder[j] > s.top()) {
                    s.pop();
                    found = true; 
                } 
                else {
                    break;
                }
            }
        }

        // If a leaf node is found, add it 
        // to the leaves vector
        if (found) {
            leaves.push_back(preorder[i]);
        }
    }

    // Since the rightmost element 
    // is always a leaf node
    leaves.push_back(preorder[n - 1]);

    return leaves; 
}


int main() {
  
    vector<int> preorder = {4, 2, 1, 3, 6, 5};
    vector<int> result = leafNodes(preorder);

    for (int val : result) {
        cout << val << " ";
    }

    return 0;
}