Given a linked list **L** of integers, the task is to return a linked list of integers such that it contains next greater element for each element in the given linked list. If there doesn’t any greater element for any element then insert **0** for it.

**Examples:**

Input:2->1->3->0->5

Output:3->3->5->5->0

Input:1->2->3

Output:2->3->0

**Naive Approach:** The naive approach is traverse the linked list **L**, and for each element in the linked list find the next greater element in the list by traversing the whole string from the current element.

**Time Complexity:** *O(N ^{2})*

**Efficient Approach:** The above naive approach can be optimized by maintaining a monotonically decreasing stack of elements traversed. If a greater element is found append it to the resultant linked list **L’** else append **0**. Below are the steps:

- Push the first node to stack.
- Pick the rest of the node one by one and follow the following steps in the loop:
- Mark the current node as next node.
- If the stack is not empty, compare the top node value of the stack with next node value.
- If next node value is greater than the top node value then, Pop the top node from the stack and next is the next greater element for the popped node.
- Keep popping the node from the stack while the popped node value is smaller than next node value. next node will becomes the next greater element for all such popped node.

- Finally, push the next node in the stack.
- After the loop in
**step 2**is over, pop all the node from the stack and print**0**as the next element for them.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// List Node ` `struct` `ListNode { ` ` ` `int` `val; ` ` ` `ListNode* next; ` ` ` `ListNode(` `int` `x) ` ` ` `{ ` ` ` `val = x; ` ` ` `next = NULL; ` ` ` `} ` `}; ` ` ` `// Function to reverse the LL ` `void` `rev(ListNode** head) ` `{ ` ` ` `ListNode *pre, *curr, *nex; ` ` ` ` ` `pre = NULL; ` ` ` `curr = *head; ` ` ` `nex = curr->next; ` ` ` ` ` `// Till current is not NULL ` ` ` `while` `(curr) { ` ` ` `curr->next = pre; ` ` ` `pre = curr; ` ` ` `curr = nex; ` ` ` `nex = (curr) ` ` ` `? curr->next ` ` ` `: NULL; ` ` ` `} ` ` ` `*head = pre; ` `} ` ` ` `// Function to print a LL node ` `void` `printList(ListNode* head) ` `{ ` ` ` `while` `(head) { ` ` ` ` ` `cout << head->val ` ` ` `<< ` `' '` `; ` ` ` `head = head->next; ` ` ` `} ` `} ` ` ` `// Function to find the next greater ` `// element in the list ` `ListNode* nextLargerLL(ListNode* head) ` `{ ` ` ` `if` `(head == NULL) ` ` ` `return` `NULL; ` ` ` ` ` `// Dummy Node ` ` ` `ListNode* res ` ` ` `= ` `new` `ListNode(-1); ` ` ` `ListNode* temp = res; ` ` ` ` ` `// Reverse the LL ` ` ` `rev(&head); ` ` ` `stack<` `int` `> st; ` ` ` ` ` `while` `(head) { ` ` ` ` ` `// Initial Condition ` ` ` `if` `(st.empty()) { ` ` ` `temp->next ` ` ` `= ` `new` `ListNode(0); ` ` ` `st.push(head->val); ` ` ` `} ` ` ` `else` `{ ` ` ` ` ` `// Maintain Monotonicity ` ` ` `// Decreasing stack of element ` ` ` `while` `(!st.empty() ` ` ` `&& st.top() ` ` ` `<= head->val) ` ` ` `st.pop(); ` ` ` ` ` `// Update result LL ` ` ` `if` `(st.empty()) { ` ` ` `temp->next ` ` ` `= ` `new` `ListNode(0); ` ` ` ` ` `st.push(head->val); ` ` ` `} ` ` ` `else` `{ ` ` ` `temp->next ` ` ` `= ` `new` `ListNode(st.top()); ` ` ` `st.push(head->val); ` ` ` `} ` ` ` `} ` ` ` `head = head->next; ` ` ` `temp = temp->next; ` ` ` `} ` ` ` ` ` `// Delete Dummy Node ` ` ` `temp = res; ` ` ` `res = res->next; ` ` ` `delete` `temp; ` ` ` ` ` `// Reverse result LL ` ` ` `rev(&res); ` ` ` `return` `res; ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `// Given Linked List ` ` ` `ListNode* head = ` `new` `ListNode(2); ` ` ` `ListNode* curr = head; ` ` ` ` ` `curr->next = ` `new` `ListNode(1); ` ` ` `curr = curr->next; ` ` ` ` ` `curr->next = ` `new` `ListNode(3); ` ` ` `curr = curr->next; ` ` ` ` ` `curr->next = ` `new` `ListNode(0); ` ` ` `curr = curr->next; ` ` ` ` ` `curr->next = ` `new` `ListNode(5); ` ` ` `curr = curr->next; ` ` ` ` ` `// Function Call ` ` ` `printList(nextLargerLL(head)); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

3 3 5 5 0

**Time Complexity:** *O(N)*

**Auxiliary Space:** *O(N)*

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Create new linked list from two given linked list with greater element at each node
- Create a linked list from two linked lists by choosing max element at each position
- Sum of nodes in a linked list which are greater than next node
- Delete all the nodes from the doubly linked list that are greater than a given value
- Delete linked list nodes which have a greater value on left side
- Second Smallest Element in a Linked List
- Move first element to end of a given Linked List
- Majority element in a linked list
- Find the element in a linked list with frequency at least N/3
- Find the first duplicate element in the linked list
- Find the Second Largest Element in a Linked List
- Move all occurrences of an element to end in a linked list
- Find a peak element in Linked List
- Rearrange a linked list in to alternate first and last element
- Move last element to front of a given Linked List
- Move last element to front of a given Linked List | Set 2
- Probability of finding an element K in a Singly Linked List
- Search an element in a Linked List (Iterative and Recursive)
- Replace every node of a Linked list with the greatest element on right side
- Maximum and Minimum element of a linked list which is divisible by a given number k

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.