Related Articles

# Next Greater Element in a Circular Linked List

• Difficulty Level : Expert
• Last Updated : 07 Jul, 2021

Given a circular singly linked list, the task is to print the next greater element for each node in the linked list. If there is no next greater element for any node, then print “-1” for that node.

Examples:

Input: head = 1 → 5 → 2 → 10 → 0 → (head)
Output: 5 10 10 -1 1
Explanation:
The next greater elements of each node are:

1. Node 1: Next greater element is 5.
2. Node 5: Next greater element is 10.
3. Node 2: Next greater element is 10.
4. Node 10: No next greater element exists. Therefore print “-1”.
5. Node 0: No next greater element exists. Therefore print “-1”.

Input: head = 1 → 5 → 12 → 10 → 0 → (head)
Output: 5 12 -1 12 1

Approach: The given problem can be solved by iterating the circular linked list to the right until the same element appears again and then print the next greater element found for each node. Follow the steps below to solve the problem:

• Initialize a Node variable, say res as NULL to store the head node of the Linked List representing the next greater element.
• Also, initialize a Node variable, say tempList as NULL to iterate over the Linked List representing the next greater element.
• Iterate over the circular Linked List and perform the following steps:
• Initialize a Node, say curr to store the reference to the current node of the circular linked list.
• Initialize a variable say Val as -1 to store the value of the next greater element of the current node.
• Perform the following steps until curr is not equal to the reference of the current node of the circular Linked List:
• If the value at the current node curr is greater than the value of the current node of the circular Linked list then assign the value of curr.data to Val and break out of the loop.
• Update the value of curr node as curr = curr.next.
• If the node res is NULL then create a new node with value Val and assign it to res, and then assign the value of res to tempList.
• Otherwise, create a new node with value Val and assign it to tempList.next, and then update the node tempList as tempList = tempList.next.
• After completing the above steps, print the elements of the Linked List res as the answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Node structure of the circular``// Linked list``struct` `Node``{``    ``int` `data;``    ``Node *next;` `    ``// Constructor``    ``Node(``int` `d)``    ``{``        ``data = d;``        ``next = NULL;``    ``}``};` `// Function to print the elements``// of a Linked list``void` `print(Node *head)``{``    ``Node *temp = head;` `    ``// Iterate the linked list``    ``while` `(temp != NULL)``    ``{``        ` `        ``// Print the data``        ``cout << temp->data << ``" "``;``        ``temp = temp->next;``    ``}``}` `// Function to find the next``// greater element for each node``void` `NextGreaterElement(Node *head)``{``    ` `    ``// Stores the head of circular``    ``// Linked list``    ``Node *H = head;` `    ``// Stores the head of the``    ``// resulting linked list``    ``Node *res = NULL;` `    ``// Stores the temporary head of``    ``// the resulting Linked list``    ``Node *tempList = NULL;` `    ``// Iterate until head``    ``// is not equal to H``    ``do``    ``{``        ` `        ``// Used to iterate over the``        ``// circular Linked List``        ``Node *curr = head;` `        ``// Stores if there exist``        ``// any next Greater element``        ``int` `Val = -1;` `        ``// Iterate until head is``        ``// not equal to curr``        ``do``        ``{``            ` `            ``// If the current node``            ``// is smaller``            ``if` `(head->data < curr->data)``            ``{``                ` `                ``// Update the value``                ``// of Val``                ``Val = curr->data;``                ``break``;``            ``}` `            ``// Update curr``            ``curr = curr->next;` `        ``} ``while` `(curr != head);` `        ``// If res is Null``        ``if` `(res == NULL)``        ``{``            ` `            ``// Create new Node with``            ``// value curr->data``            ``res = ``new` `Node(Val);` `            ``// Assign address of``            ``// res to tempList``            ``tempList = res;``        ``}``        ``else``        ``{``            ` `            ``// Update tempList``            ``tempList->next = ``new` `Node(Val);` `            ``// Assign address of the``            ``// next node to tempList``            ``tempList = tempList->next;``        ``}` `        ``// Update the value of``        ``// head node``        ``head = head->next;``    ``} ``while` `(head != H);` `    ``// Print the resulting``    ``// Linked list``    ``print(res);``}` `// Driver code``int` `main()``{``    ``Node *head = ``new` `Node(1);``    ``head->next = ``new` `Node(5);``    ``head->next->next = ``new` `Node(12);``    ``head->next->next->next = ``new` `Node(10);``    ` `    ``head->next->next->next->next = ``new` `Node(0);``    ``head->next->next->next->next->next = head;``    ` `    ``NextGreaterElement(head);``    ` `    ``return` `0;``}` `// This code is contributed by mohit kumar 29`

## Java

 `// Java program for the above approach` `import` `java.io.*;``import` `java.util.*;` `class` `GFG {``    ``static` `Node head;` `    ``// Node structure of the circular``    ``// Linked list``    ``static` `class` `Node {``        ``int` `data;``        ``Node next;` `        ``// Constructor``        ``public` `Node(``int` `data)``        ``{``            ``this``.data = data;``            ``this``.next = ``null``;``        ``}``    ``}` `    ``// Function to print the elements``    ``// of a Linked list``    ``static` `void` `print(Node head)``    ``{``        ``Node temp = head;` `        ``// Iterate the linked list``        ``while` `(temp != ``null``) {` `            ``// Print the data``            ``System.out.print(``                ``temp.data + ``" "``);``            ``temp = temp.next;``        ``}``    ``}` `    ``// Function to find the next``    ``// greater element for each node``    ``static` `void` `NextGreaterElement(Node head)``    ``{``        ``// Stores the head of circular``        ``// Linked list``        ``Node H = head;` `        ``// Stores the head of the``        ``// resulting linked list``        ``Node res = ``null``;` `        ``// Stores the temporary head of``        ``// the resulting Linked list``        ``Node tempList = ``null``;` `        ``// Iterate until head``        ``// is not equal to H``        ``do` `{` `            ``// Used to iterate over the``            ``// circular Linked List``            ``Node curr = head;` `            ``// Stores if there exist``            ``// any next Greater element``            ``int` `Val = -``1``;` `            ``// Iterate until head is``            ``// not equal to curr``            ``do` `{` `                ``// If the current node``                ``// is smaller``                ``if` `(head.data < curr.data) {` `                    ``// Update the value``                    ``// of Val``                    ``Val = curr.data;``                    ``break``;``                ``}` `                ``// Update curr``                ``curr = curr.next;` `            ``} ``while` `(curr != head);` `            ``// If res is Null``            ``if` `(res == ``null``) {` `                ``// Create new Node with``                ``// value curr.data``                ``res = ``new` `Node(Val);` `                ``// Assign address of``                ``// res to tempList``                ``tempList = res;``            ``}``            ``else` `{` `                ``// Update tempList``                ``tempList.next = ``new` `Node(Val);` `                ``// Assign address of the``                ``// next node to tempList``                ``tempList = tempList.next;``            ``}` `            ``// Update the value of``            ``// head node``            ``head = head.next;``        ``} ``while` `(head != H);` `        ``// Print the resulting``        ``// Linked list``        ``print(res);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``head = ``new` `Node(``1``);``        ``head.next = ``new` `Node(``5``);``        ``head.next.next = ``new` `Node(``12``);``        ``head.next.next.next = ``new` `Node(``10``);` `        ``head.next.next.next.next = ``new` `Node(``0``);``        ``head.next.next.next.next.next = head;` `        ``NextGreaterElement(head);``    ``}``}`

## C#

 `// C# program for the above approach``using` `System;` `// Node structure of the circular``// Linked list``class` `Node``{``    ``public` `int` `data;``    ``public` `Node next;` `    ``// Constructor``    ``public` `Node(``int` `data)``    ``{``        ``this``.data = data;``        ``this``.next = ``null``;``    ``}``}` `class` `GFG{``    ` `static` `Node head;` `// Function to print the elements``// of a Linked list``static` `void` `print(Node head)``{``    ``Node temp = head;` `    ``// Iterate the linked list``    ``while` `(temp != ``null``)``    ``{``        ` `        ``// Print the data``        ``Console.Write(temp.data + ``" "``);``        ``temp = temp.next;``    ``}``}` `// Function to find the next``// greater element for each node``static` `void` `NextGreaterElement(Node head)``{``    ` `    ``// Stores the head of circular``    ``// Linked list``    ``Node H = head;` `    ``// Stores the head of the``    ``// resulting linked list``    ``Node res = ``null``;` `    ``// Stores the temporary head of``    ``// the resulting Linked list``    ``Node tempList = ``null``;` `    ``// Iterate until head``    ``// is not equal to H``    ``do``{``        ` `        ``// Used to iterate over the``        ``// circular Linked List``        ``Node curr = head;` `        ``// Stores if there exist``        ``// any next Greater element``        ``int` `Val = -1;` `        ``// Iterate until head is``        ``// not equal to curr``        ``do``{``            ` `            ``// If the current node``            ``// is smaller``            ``if` `(head.data < curr.data)``            ``{``                ` `                ``// Update the value``                ``// of Val``                ``Val = curr.data;``                ``break``;``            ``}` `            ``// Update curr``            ``curr = curr.next;` `        ``} ``while` `(curr != head);` `        ``// If res is Null``        ``if` `(res == ``null``)``        ``{``            ` `            ``// Create new Node with``            ``// value curr.data``            ``res = ``new` `Node(Val);` `            ``// Assign address of``            ``// res to tempList``            ``tempList = res;``        ``}``        ``else``        ``{``            ` `            ``// Update tempList``            ``tempList.next = ``new` `Node(Val);` `            ``// Assign address of the``            ``// next node to tempList``            ``tempList = tempList.next;``        ``}` `        ``// Update the value of``        ``// head node``        ``head = head.next;``    ``} ``while` `(head != H);` `    ``// Print the resulting``    ``// Linked list``    ``print(res);``}` `// Driver Code``static` `public` `void` `Main()``{``    ``head = ``new` `Node(1);``    ``head.next = ``new` `Node(5);``    ``head.next.next = ``new` `Node(12);``    ``head.next.next.next = ``new` `Node(10);` `    ``head.next.next.next.next = ``new` `Node(0);``    ``head.next.next.next.next.next = head;` `    ``NextGreaterElement(head);``}``}` `// This code is contributed by unknown2108`

## Javascript

 ``
Output:
`5 12 -1 12 1`

Time Complexity: O(N2)
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up