Next greater element

	
// A Stack based C++ program to find next 
// greater element for all array elements. 
#include <bits/stdc++.h> 
using namespace std; 

/* prints element and NGE pair for all 
elements of arr[] of size n */
void printNGE(int arr[], int n) { 
stack < int > s; 

/* push the first element to stack */
s.push(arr[0]); 

// iterate for rest of the elements 
for (int i = 1; i < n; i++) { 

	if (s.empty()) { 
	s.push(arr[i]); 
	continue; 
	} 

	/* if stack is not empty, then 
	pop an element from stack. 
	If the popped element is smaller 
	than next, then 
	a) print the pair 
	b) keep popping while elements are 
	smaller and stack is not empty */
	while (s.empty() == false && s.top() < arr[i]) 
	{		 
		cout << s.top() << " --> " << arr[i] << endl; 
		s.pop(); 
	} 

	/* push next to stack so that we can find 
	next greater for it */
	s.push(arr[i]); 
} 

/* After iterating over the loop, the remaining 
elements in stack do not have the next greater 
element, so print -1 for them */
while (s.empty() == false) { 
	cout << s.top() << " --> " << -1 << endl; 
	s.pop(); 
} 
} 

/* Driver program to test above functions */
int main() { 
int arr[] = {11, 13, 21, 3}; 
int n = sizeof(arr) / sizeof(arr[0]); 
printNGE(arr, n); 
return 0; 
}

You are teaching very good sir.

dont copy code from gfg.

`class Solution {

public static int [] nextGreaterElement(int [] a) {
/* write your solution here */
int n=a.length;
int[] b=new int[n];
for(int i=0;i<n;i++)
{
b[i]=-1;
}
Stack st=new Stack();
st.push(0);
for(int i=1;i<n;i++)
{
//int top=st.peek();
while(!st.empty()&&a[st.peek()]<a[i])
{
b[st.peek()]=a[i];
st.pop();
}
st.push(i);
}
return b;
}
}`

this solution is too complicated and would give a runtime error on most platforms. Please try simplifying it.

Java code ,
same approach as sir has followed

 public static long[] solveNextLargerElement(long[] arr,int n){
        long[] ans  = new long[n];
        
        Stack<Integer> stack = new Stack<>();
        
        for(int i=0;i< n;i++){
            if(stack.size()==0){
                stack.push(i);
                continue;
            }
            
            while(stack.size()>0 && arr[i] > arr[stack.peek()]){
                ans[stack.pop()]= arr[i];
            }
            
            stack.push(i);
            
           
            
        }
        
        while(stack.size()>0){
            ans[stack.pop()]=-1;
        }
        
        return ans;
    }

Java code , same approach as sir has followed

 public static long[] solveNextLargerElement(long[] arr,int n){
        long[] ans  = new long[n];
        
        Stack<Integer> stack = new Stack<>();
        
        for(int i=0;i< n;i++){
            if(stack.size()==0){
                stack.push(i);
                continue;
            }
            
            while(stack.size()>0 && arr[i] > arr[stack.peek()]){
                ans[stack.pop()]= arr[i];
            }
            
            stack.push(i);
            
           
            
        }
        
        while(stack.size()>0){
            ans[stack.pop()]=-1;
        }
        
        return ans;
    }

Thanks 😁

For my snake lovers:

def solve_next_larger_element(arr, n):
    ans = [-1] * n 
    
    stack = []
    
    for i in range(n):
      
        while stack and arr[i] > arr[stack[-1]]:
            ans[stack.pop()] = arr[i]
        
        # Push current index onto the stack
        stack.append(i)
    

    return ans