Replace every element with the least greater element on its right

// Java program to replace every element with
// the least greater element on its right
import java.io.*;

class BinarySearchTree {

    // A binary Tree node
    class Node {
        int data;
        Node left, right;

        Node(int d)
        {
            data = d;
            left = right = null;
        }
    }

    // Root of BST
    static Node root;
    static Node succ;

    // Constructor
    BinarySearchTree()
    {
        root = null;
        succ = null;
    }

    // A utility function to insert a new node with
    // given data in BST and find its successor
    Node insert(Node node, int data)
    {

        // If the tree is empty, return a new node
        if (node == null) {
            node = new Node(data);
        }

        // If key is smaller than root's key,
        // go to left subtree and set successor
        // as current node
        if (data < node.data) {
            succ = node;
            node.left = insert(node.left, data);
        }

        // Go to right subtree
        else if (data > node.data)
            node.right = insert(node.right, data);

        return node;
    }

    // Function to replace every element with the
    // least greater element on its right
    static void replace(int arr[], int n)
    {
        BinarySearchTree tree = new BinarySearchTree();

        // start from right to left
        for (int i = n - 1; i >= 0; i--) {
            succ = null;

            // Insert current element into BST and
            // find its inorder successor
            root = tree.insert(root, arr[i]);

            // Replace element by its inorder
            // successor in BST
            if (succ != null)
                arr[i] = succ.data;

            // No inorder successor
            else
                arr[i] = -1;
        }
    }

    // Driver code
    public static void main(String[] args)
    {
        int arr[]
            = new int[] { 8,  58, 71, 18, 31, 32, 63, 92,
                          43, 3,  91, 93, 25, 80, 28 };
        int n = arr.length;

        replace(arr, n);

        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
    }
}

// The code is contributed by Tushar Bansal

// Java program for above approach

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Stack;

public class GFF {

    // function to get the next least greater index for each
    // and every temp.second of the temp array using stack
    // this function is similar to the Next Greater element
    // for each and every element of an array using stack
    // difference is we are finding the next greater index
    // not value and the indexes are stored in the
    // temp[i].second for all i
    static int[] nextGreaterIndex(ArrayList<int[]> temp)
    {
        int n = temp.size();
        // initially result[i] for all i is -1
        int[] res = new int[n];
        Arrays.fill(res, -1);
        Stack<Integer> stack = new Stack<Integer>();
        for (int i = 0; i < n; i++) {
            // if the stack is empty or this index is
            // smaller than the index stored at top of the
            // stack then we push this index to the stack
            if (stack.empty()
                || temp.get(i)[1] < stack.peek())
                stack.push(temp.get(
                    i)[1]); // notice temp[i].second is
                            // the index
            // else this index (i.e. temp[i].second) is
            // greater than the index stored at top of the
            // stack we pop all the indexes stored at
            // stack's top and for all these indexes we make
            // this index i.e. temp[i].second as their next
            // greater index
            else {
                while (!stack.empty()
                       && temp.get(i)[1] > stack.peek()) {
                    res[stack.peek()] = temp.get(i)[1];
                    stack.pop();
                }
                // after that push the current index to the
                // stack
                stack.push(temp.get(i)[1]);
            }
        }
        // now res will store the next least greater indexes
        // for each and every indexes stored at
        // temp[i].second for all i
        return res;
    }

    // now we will be using above function for finding the
    // next greater index for each and every indexes stored
    // at temp[i].second
    static int[] replaceByLeastGreaterUsingStack(int arr[],
                                                 int n)
    {
        // first of all in temp we store the pairs of
        // {arr[i].i}
        ArrayList<int[]> temp = new ArrayList<int[]>();
        for (int i = 0; i < n; i++) {
            temp.add(new int[] { arr[i], i });
        }
        // we sort the temp according to the first of the
        // pair i.e value
        Collections.sort(temp, (a, b) -> {
            if (a[0] == b[0])
                return b[1] - a[1];
            return a[0] - b[0];
        });

        // now indexes vector will store the next greater
        // index for each temp[i].second index
        int[] indexes = nextGreaterIndex(temp);
        // we initialize a result vector with all -1
        int[] res = new int[n];
        Arrays.fill(res, -1);
        for (int i = 0; i < n; i++) {
            // now if there is no next greater index after
            // the index temp[i].second the result will be
            // -1 otherwise the result will be the element
            // of the array arr at index
            // indexes[temp[i].second]
            if (indexes[temp.get(i)[1]] != -1)
                res[temp.get(i)[1]]
                    = arr[indexes[temp.get(i)[1]]];
        }
        // return the res which will store the least greater
        // element of each and every element in the array at
        // its right side
        return res;
    }

    // driver code
    public static void main(String[] args)
    {
        int arr[] = { 8,  58, 71, 18, 31, 32, 63, 92,
                      43, 3,  91, 93, 25, 80, 28 };
        int n = arr.length;
        int[] res = replaceByLeastGreaterUsingStack(arr, n);
        System.out.println(
            "Least Greater elements on the right side are ");
        for (int i : res)
            System.out.print(i + " ");
        System.out.println();
    }
}

// This code is contributed by Lovely Jain

import java.util.*;

public class Main {
    public static void main(String[] args)
    {
        int[] arr = { 8,  58, 71, 18, 31, 32, 63, 92,
                      43, 3,  91, 93, 25, 80, 28 };
        printArray(arr);
        solve(arr);
        printArray(arr);
    }
    public static void solve(int[] arr)
    {
        TreeSet<Integer> s = new TreeSet<>();
        for (int i = arr.length - 1; i >= 0;
             i--) { // traversing the array backwards
            s.add(arr[i]); // inserting the element into set
            Integer it
                = s.higher(arr[i]); // finding upper bound
                                    // (higher in java)
            if (it == null)
                arr[i] = -1; // if upper_bound does not
                             // exist then -1
            else
                arr[i] = it; // if upper_bound exists, lets
                             // take it
        }
    }
    public static void printArray(int[] arr)
    {
        for (int i : arr)
            System.out.print(i + " ");
        System.out.println();
    }
}

// This code is contributed by Tapesh (tapeshdua420)

import java.util.ArrayList;
import java.util.List;

public class Main {

    // Function to replace each element in the input list with the least greater element to its right.
    public static List<Integer> replaceWithLeastGreater(List<Integer> arr) {
        int n = arr.size();
        List<Integer> newArr = new ArrayList<>(n);
        
        for (int i = 0; i < n; i++) {
            int minGreater = Integer.MAX_VALUE; // Initialize minGreater to a very large value.

            // Iterate through elements to the right of the current element.
            for (int j = i + 1; j < n; j++) {
                // Check if the current element is greater than the current minimum greater element
                // found so far and is smaller than any previously found minimum greater element.
                if (arr.get(j) > arr.get(i) && arr.get(j) < minGreater) {
                    minGreater = arr.get(j); // Update minGreater with the new minimum greater element.
                }
            }

            if (minGreater != Integer.MAX_VALUE) {
                newArr.add(minGreater); // Add the minimum greater element to the new list.
            } else {
                newArr.add(-1); // If no greater element was found, add -1 to the new list.
            }
        }

        return newArr; // Return the list with replaced elements.
    }

    public static void main(String[] args) {
        // Create an input list of integers.
        List<Integer> arr = List.of(8, 58, 71, 18, 31, 32, 63, 92, 43, 3, 91, 93, 25, 80, 28);
        
        // Call the replaceWithLeastGreater function to get the result.
        List<Integer> result = replaceWithLeastGreater(arr);

        // Print the result
        for (int val : result) {
            System.out.print(val + " "); // Print each element in the result list.
        }
        System.out.println();
    }
}