Open In App

# Delete nodes which have a greater value on right side

Given a singly linked list, remove all the nodes which have a greater value on the right side.

Examples:
a) The list 12->15->10->11->5->6->2->3->NULL should be changed to 15->11->6->3->NULL. Note that 12, 10, 5 and 2 have been deleted because there is a greater value on the right side.
When we examine 12, we see that after 12 there is one node with a value greater than 12 (i.e. 15), so we delete 12.
When we examine 15, we find no node after 15 that has a value greater than 15, so we keep this node.
When we go like this, we get 15->11->6->3->NULL
b) The list 10->20->30->40->50->60->NULL should be changed to 60->NULL. Note that 10, 20, 30, 40, and 50 have been deleted because they all have a greater value on the right side.
c) The list 60->50->40->30->20->10->NULL should not be changed.

Method 1 (Simple)
Use two loops. In the outer loop, pick nodes of the linked list one by one. In the inner loop, check if there exists a node whose value is greater than the picked node. If there exists a node whose value is greater, then delete the picked node.
Time Complexity: O(n^2)
Auxiliary Space: O(1)

Method 2 (Use Reverse)
Thanks to Paras for providing the below algorithm.
1. Reverse the list.
2. Traverse the reversed list. Keep max till now. If the next node is less than max, then delete the next node, otherwise max = next node.
3. Reverse the list again to retain the original order.
Thanks to R.Srinivasan for providing the code below.

## C++

 `// C++ program to delete nodes``// which have a greater value on``// right side``#include ``using` `namespace` `std;` `/* structure of a linked list node */``struct` `Node``{``    ``int` `data;``    ``struct` `Node* next;``};` `/* prototype for utility functions */``void` `reverseList(``struct` `Node** headref);``void` `_delLesserNodes(``struct` `Node* head);` `/* Deletes nodes which have a node with``greater value node on left side */``void` `delLesserNodes(``struct` `Node** head_ref)``{``    ``/* 1) Reverse the linked list */``    ``reverseList(head_ref);` `    ``/* 2) In the reversed list, delete nodes``    ``which have a node with greater value node``    ``on left side. Note that head node is never``    ``deleted because it is the leftmost node.*/``    ``_delLesserNodes(*head_ref);` `    ``/* 3) Reverse the linked list again to``    ``retain the original order */``    ``reverseList(head_ref);``}` `/* Deletes nodes which have``greater value node(s) on left side */``void` `_delLesserNodes(``struct` `Node* head)``{``    ``struct` `Node* current = head;` `    ``/* Initialize max */``    ``struct` `Node* maxnode = head;``    ``struct` `Node* temp;` `    ``while` `(current != NULL &&``           ``current->next != NULL)``    ``{``        ``/* If current is smaller than max,``        ``then delete current */``        ``if` `(current->next->data < maxnode->data)``        ``{``            ``temp = current->next;``            ``current->next = temp->next;``            ``free``(temp);``        ``}` `        ``/* If current is greater than max,``            ``then update max and move current */``        ``else``        ``{``            ``current = current->next;``            ``maxnode = current;``        ``}``    ``}``}` `/* Utility function to insert a node``at the beginning */``void` `push(``struct` `Node** head_ref, ``int` `new_data)``{``    ``struct` `Node* new_node = (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));``    ``new_node->data = new_data;``    ``new_node->next = *head_ref;``    ``*head_ref = new_node;``}` `/* Utility function to reverse a linked list */``void` `reverseList(``struct` `Node** headref)``{``    ``struct` `Node* current = *headref;``    ``struct` `Node* prev = NULL;``    ``struct` `Node* next;``    ``while` `(current != NULL)``    ``{``        ``next = current->next;``        ``current->next = prev;``        ``prev = current;``        ``current = next;``    ``}``    ``*headref = prev;``}` `/* Utility function to print a linked list */``void` `printList(``struct` `Node* head)``{``    ``while` `(head != NULL)``    ``{``        ``cout << ``" "` `<< head->data ;``        ``head = head->next;``    ``}``    ``cout << ``"\n"` `;``}` `/* Driver program to test above functions */``int` `main()``{``    ``struct` `Node* head = NULL;` `    ``/* Create following linked list``    ``12->15->10->11->5->6->2->3 */``    ``push(&head, 3);``    ``push(&head, 2);``    ``push(&head, 6);``    ``push(&head, 5);``    ``push(&head, 11);``    ``push(&head, 10);``    ``push(&head, 15);``    ``push(&head, 12);` `    ``cout << ``"Given Linked List \n"` `;``    ``printList(head);` `    ``delLesserNodes(&head);` `    ``cout << ``"Modified Linked List \n"` `;``    ``printList(head);` `    ``return` `0;``}` `// This code is contributed by shivanisinghss2110`

## C

 `// C program to delete nodes which have a greater value on``// right side``#include ``#include ` `/* structure of a linked list node */``struct` `Node {``    ``int` `data;``    ``struct` `Node* next;``};` `/* prototype for utility functions */``void` `reverseList(``struct` `Node** headref);``void` `_delLesserNodes(``struct` `Node* head);` `/* Deletes nodes which have a node with greater value node``  ``on left side */``void` `delLesserNodes(``struct` `Node** head_ref)``{``    ``/* 1) Reverse the linked list */``    ``reverseList(head_ref);` `    ``/* 2) In the reversed list, delete nodes which have a node``       ``with greater value node on left side. Note that head``       ``node is never deleted because it is the leftmost node.*/``    ``_delLesserNodes(*head_ref);` `    ``/* 3) Reverse the linked list again to retain the``       ``original order */``    ``reverseList(head_ref);``}` `/* Deletes nodes which have greater value node(s) on left side */``void` `_delLesserNodes(``struct` `Node* head)``{``    ``struct` `Node* current = head;` `    ``/* Initialize max */``    ``struct` `Node* maxnode = head;``    ``struct` `Node* temp;` `    ``while` `(current != NULL && current->next != NULL) {``        ``/* If current is smaller than max, then delete current */``        ``if` `(current->next->data < maxnode->data) {``            ``temp = current->next;``            ``current->next = temp->next;``            ``free``(temp);``        ``}` `        ``/* If current is greater than max, then update max and``            ``move current */``        ``else` `{``            ``current = current->next;``            ``maxnode = current;``        ``}``    ``}``}` `/* Utility function to insert a node at the beginning */``void` `push(``struct` `Node** head_ref, ``int` `new_data)``{``    ``struct` `Node* new_node = (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));``    ``new_node->data = new_data;``    ``new_node->next = *head_ref;``    ``*head_ref = new_node;``}` `/* Utility function to reverse a linked list */``void` `reverseList(``struct` `Node** headref)``{``    ``struct` `Node* current = *headref;``    ``struct` `Node* prev = NULL;``    ``struct` `Node* next;``    ``while` `(current != NULL) {``        ``next = current->next;``        ``current->next = prev;``        ``prev = current;``        ``current = next;``    ``}``    ``*headref = prev;``}` `/* Utility function to print a linked list */``void` `printList(``struct` `Node* head)``{``    ``while` `(head != NULL) {``        ``printf``(``"%d "``, head->data);``        ``head = head->next;``    ``}``    ``printf``(``"\n"``);``}` `/* Driver program to test above functions */``int` `main()``{``    ``struct` `Node* head = NULL;` `    ``/* Create following linked list``      ``12->15->10->11->5->6->2->3 */``    ``push(&head, 3);``    ``push(&head, 2);``    ``push(&head, 6);``    ``push(&head, 5);``    ``push(&head, 11);``    ``push(&head, 10);``    ``push(&head, 15);``    ``push(&head, 12);` `    ``printf``(``"Given Linked List \n"``);``    ``printList(head);` `    ``delLesserNodes(&head);` `    ``printf``(``"Modified Linked List \n"``);``    ``printList(head);` `    ``return` `0;``}`

## Java

 `// Java program to delete nodes which have a greater value on``// right side``class` `LinkedList {``    ``Node head; ``// head of list` `    ``/* Linked list Node*/``    ``class` `Node {``        ``int` `data;``        ``Node next;``        ``Node(``int` `d)``        ``{``            ``data = d;``            ``next = ``null``;``        ``}``    ``}` `    ``/* Deletes nodes which have a node with greater``       ``value node on left side */``    ``void` `delLesserNodes()``    ``{``        ``/* 1.Reverse the linked list */``        ``reverseList();` `        ``/* 2) In the reversed list, delete nodes which``           ``have a node with greater value node on left``           ``side. Note that head node is never deleted``           ``because it is the leftmost node.*/``        ``_delLesserNodes();` `        ``/* 3) Reverse the linked list again to retain``           ``the original order */``        ``reverseList();``    ``}` `    ``/* Deletes nodes which have greater value node(s)``       ``on left side */``    ``void` `_delLesserNodes()``    ``{``        ``Node current = head;` `        ``/* Initialise max */``        ``Node maxnode = head;``        ``Node temp;` `        ``while` `(current != ``null` `&& current.next != ``null``) {``            ``/* If current is smaller than max, then delete``               ``current */``            ``if` `(current.next.data < maxnode.data) {``                ``temp = current.next;``                ``current.next = temp.next;``                ``temp = ``null``;``            ``}` `            ``/* If current is greater than max, then update``               ``max and move current */``            ``else` `{``                ``current = current.next;``                ``maxnode = current;``            ``}``        ``}``    ``}` `    ``/* Utility functions */` `    ``/* Inserts a new Node at front of the list. */``    ``void` `push(``int` `new_data)``    ``{``        ``/* 1 & 2: Allocate the Node &``                  ``Put in the data*/``        ``Node new_node = ``new` `Node(new_data);` `        ``/* 3. Make next of new Node as head */``        ``new_node.next = head;` `        ``/* 4. Move the head to point to new Node */``        ``head = new_node;``    ``}` `    ``/* Function to reverse the linked list */``    ``void` `reverseList()``    ``{``        ``Node current = head;``        ``Node prev = ``null``;``        ``Node next;``        ``while` `(current != ``null``) {``            ``next = current.next;``            ``current.next = prev;``            ``prev = current;``            ``current = next;``        ``}``        ``head = prev;``    ``}` `    ``/* Function to print linked list */``    ``void` `printList()``    ``{``        ``Node temp = head;``        ``while` `(temp != ``null``) {``            ``System.out.print(temp.data + ``" "``);``            ``temp = temp.next;``        ``}``        ``System.out.println();``    ``}` `    ``/* Driver program to test above functions */``    ``public` `static` `void` `main(String args[])``    ``{``        ``LinkedList llist = ``new` `LinkedList();` `        ``/* Constructed Linked List is 12->15->10->11->``           ``5->6->2->3 */``        ``llist.push(``3``);``        ``llist.push(``2``);``        ``llist.push(``6``);``        ``llist.push(``5``);``        ``llist.push(``11``);``        ``llist.push(``10``);``        ``llist.push(``15``);``        ``llist.push(``12``);` `        ``System.out.println(``"Given Linked List"``);``        ``llist.printList();` `        ``llist.delLesserNodes();` `        ``System.out.println(``"Modified Linked List"``);``        ``llist.printList();``    ``}``} ``/* This code is contributed by Rajat Mishra */`

## Python3

 `# Python program to delete nodes which have a``# greater value on right side``class` `Node:` `    ``# constructor to initialize the node object``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.``next` `=` `None` `class` `LinkedList:` `    ``# Function to initialize head``    ``def` `__init__(``self``):``        ``self``.head ``=` `None` `    ``# Function to insert a new node at beginning``    ``def` `push(``self``, new_data):``        ``new_node ``=` `Node(new_data)``        ``new_node.``next` `=` `self``.head``        ``self``.head ``=` `new_node` `    ``# Utility function to print a linked list``    ``def` `printList(``self``):``        ``temp ``=` `self``.head``        ``while``(temp ``is` `not` `None``):``            ``print``(temp.data, end``=``" "``)``            ``temp ``=` `temp.``next``        ``print``(``"\n"``)` `    ``def` `delLesserNodes(``self``):``        ``# Reverse the linked list``        ``self``.reverseList()` `        ``# In the reversed list, delete nodes which have a node with greater``        ``# value node on left side. Note that head node is never deleted because``        ``# it is the leftmost node.``        ``self``._delLesserNodes()` `        ``# Reverse the linked list again to retain the original order``        ``self``.reverseList()` `    ``# Deletes nodes which have greater value node(s) on left side``    ``def` `_delLesserNodes(``self``):``        ``current ``=` `self``.head``        ``# Initialize max``        ``maxnode ``=` `self``.head` `        ``while``(current ``is` `not` `None` `and` `current.``next` `is` `not` `None``):``            ``# If current is smaller than max, then delete current``            ``if``(current.``next``.data < maxnode.data):``                ``temp ``=` `current.``next``                ``current.``next` `=` `temp.``next` `            ``# If current is greater than max, then update max and move current``            ``else``:``                ``current ``=` `current.``next``                ``maxnode ``=` `current` `    ``# Utility function to reverse a linked list``    ``def` `reverseList(``self``):``        ``current ``=` `self``.head``        ``prev ``=` `None``        ``while``(current ``is` `not` `None``):``            ``next` `=` `current.``next``            ``current.``next` `=` `prev``            ``prev ``=` `current``            ``current ``=` `next``        ``self``.head ``=` `prev`  `# Create following linked list``# 12->15->10->11->5->6->2->3``llist ``=` `LinkedList()``llist.push(``3``)``llist.push(``2``)``llist.push(``6``)``llist.push(``5``)``llist.push(``11``)``llist.push(``10``)``llist.push(``15``)``llist.push(``12``)` `print``(``"Given linked list"``)``llist.printList()` `llist.delLesserNodes()` `print``(``"Modified Linked List"``)``llist.printList()` `# This code is contributed by Yash Agarwal(yashagarwal2852002)`

## C#

 `// C# program to delete nodes which have a greater value on``// right side``using` `System;` `class` `LinkedList``{``    ``public` `Node head; ``// head of list` `    ``/* Linked list Node*/``    ``public` `class` `Node``    ``{``        ``public` `int` `data;``        ``public` `Node next;``        ``public` `Node(``int` `d)``        ``{``            ``data = d;``            ``next = ``null``;``        ``}``    ``}` `    ``/* Deletes nodes which have a node with greater``       ``value node on left side */``    ``void` `delLesserNodes()``    ``{``      ` `        ``/* 1.Reverse the linked list */``        ``reverseList();` `        ``/* 2) In the reversed list, delete nodes which``           ``have a node with greater value node on left``           ``side. Note that head node is never deleted``           ``because it is the leftmost node.*/``        ``_delLesserNodes();` `        ``/* 3) Reverse the linked list again to retain``           ``the original order */``        ``reverseList();``    ``}` `    ``/* Deletes nodes which have greater value node(s)``       ``on left side */``    ``void` `_delLesserNodes()``    ``{``        ``Node current = head;` `        ``/* Initialise max */``        ``Node maxnode = head;``        ``Node temp;` `        ``while` `(current != ``null` `&& current.next != ``null``)``        ``{``          ` `            ``/* If current is smaller than max, then delete``               ``current */``            ``if` `(current.next.data < maxnode.data)``            ``{``                ``temp = current.next;``                ``current.next = temp.next;``                ``temp = ``null``;``            ``}` `            ``/* If current is greater than max, then update``               ``max and move current */``            ``else``            ``{``                ``current = current.next;``                ``maxnode = current;``            ``}``        ``}``    ``}` `    ``/* Utility functions */` `    ``/* Inserts a new Node at front of the list. */``    ``void` `push(``int` `new_data)``    ``{``      ` `        ``/* 1 & 2: Allocate the Node &``                  ``Put in the data*/``        ``Node new_node = ``new` `Node(new_data);` `        ``/* 3. Make next of new Node as head */``        ``new_node.next = head;` `        ``/* 4. Move the head to point to new Node */``        ``head = new_node;``    ``}` `    ``/* Function to reverse the linked list */``    ``void` `reverseList()``    ``{``        ``Node current = head;``        ``Node prev = ``null``;``        ``Node next;``        ``while` `(current != ``null``)``        ``{``            ``next = current.next;``            ``current.next = prev;``            ``prev = current;``            ``current = next;``        ``}``        ``head = prev;``    ``}` `    ``/* Function to print linked list */``    ``void` `printList()``    ``{``        ``Node temp = head;``        ``while` `(temp != ``null``)``        ``{``            ``Console.Write(temp.data + ``" "``);``            ``temp = temp.next;``        ``}``        ``Console.WriteLine();``    ``}` `    ``/* Driver program to test above functions */``    ``public` `static` `void` `Main(``string` `[]args)``    ``{``        ``LinkedList llist = ``new` `LinkedList();` `        ``/* Constructed Linked List is 12->15->10->11->``           ``5->6->2->3 */``        ``llist.push(3);``        ``llist.push(2);``        ``llist.push(6);``        ``llist.push(5);``        ``llist.push(11);``        ``llist.push(10);``        ``llist.push(15);``        ``llist.push(12);` `        ``Console.WriteLine(``"Given Linked List"``);``        ``llist.printList();``        ``llist.delLesserNodes();``        ``Console.WriteLine(``"Modified Linked List"``);``        ``llist.printList();``    ``}``}` `// This code is contributed by pratham76`

## Javascript

 ``

Output

```Given Linked List
12 15 10 11 5 6 2 3
15 11 6 3
```

Time complexity: O(n) where n is no of nodes in the Linked list
Auxiliary Space: O(1)

Method 3:
The other simpler method is to traverse the list from the start and delete the node when the current Node < next Node. To delete the current node, follow this approach.

Let us assume you have to delete current node X

• Copy next node’s data into X i.e X.data = X.next.data
• Copy next node’s next address i.e X.next = X.next.next;

Move forward in the List only when the current Node is > the next Node.

## C++

 `#include ``using` `namespace` `std;` `// This class represents a single node in a linked list``class` `Node {``public``:``    ``int` `data;``    ``Node* next;``    ` `    ``Node(``int` `data) {``        ``this``->data = data;``        ``this``->next = nullptr;``    ``}``};` `// This is a utility class for linked list``class` `LLUtil {``public``:``    ``// This function creates a linked list from a given array and returns head``    ``Node* createLL(``int` `arr[], ``int` `n) {``        ``Node* head = ``new` `Node(arr[0]);``        ``Node* temp = head;``        ` `        ``Node* newNode = nullptr;``        ``for``(``int` `i = 1; i < n; i++) {``            ``newNode = ``new` `Node(arr[i]);``            ``temp->next = newNode;``            ``temp = temp->next;``        ``}``        ``return` `head;``    ``}``    ` `    ``// This function prints the given linked list``    ``void` `printLL(Node* head) {``        ``while``(head != nullptr) {``            ``cout << head->data << ``" "``;``            ``head = head->next;``        ``}``        ``cout << endl;``    ``}``};` `// This function deletes nodes on the right side of the linked list``Node* deleteNodesOnRightSide(Node* head) {``    ``if``(head == nullptr || head->next == nullptr) {``        ``return` `head;``    ``}``    ` `    ``Node* nextNode = deleteNodesOnRightSide(head->next);``    ` `    ``if``(nextNode->data > head->data) {``        ``return` `nextNode;``    ``}``    ` `    ``head->next = nextNode;``    ` `    ``return` `head;``}` `int` `main() {``    ``int` `arr[] = {12, 15, 10, 11, 5, 6, 2, 3};``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ` `    ``LLUtil llu;``    ``Node* head = llu.createLL(arr, n);``    ` `    ``cout << ``"Given Linked List"` `<< endl;``    ``llu.printLL(head);``    ` `    ``head = deleteNodesOnRightSide(head);``    ` `    ``cout << ``"Modified Linked List"` `<< endl;``    ``llu.printLL(head);``    ` `    ``return` `0;``}`

## Java

 `// Java program for above approach``import` `java.io.*;` `// This class represents a single node``// in a linked list``class` `Node {``    ` `    ``int` `data;``    ``Node next;``    ` `    ``public` `Node(``int` `data){``        ``this``.data = data;``        ``this``.next = ``null``;``    ``}``}` `//This is a utility class for linked list``class` `LLUtil{``    ` `      ``// This function creates a linked list from a``    ``// given array and returns head``    ``public` `Node createLL(``int``[] arr){``        ` `        ``Node head = ``new` `Node(arr[``0``]);``        ``Node temp = head;``        ` `        ``Node newNode = ``null``;``        ``for``(``int` `i = ``1``; i < arr.length; i++){``            ``newNode = ``new` `Node(arr[i]);``            ``temp.next = newNode;``            ``temp = temp.next;``        ``}``        ``return` `head;``    ``}``  ` `      ``//This function prints given linked list``      ``public` `void` `printLL(Node head){``        ` `        ``while``(head != ``null``){``            ``System.out.print(head.data + ``" "``);``            ``head = head.next;``        ``}``        ``System.out.println();``    ``}``  ` `  ` `}` `class` `GFG {``    ``public` `static` `void` `main (String[] args) {``        ` `          ``int``[] arr = {``12``,``15``,``10``,``11``,``5``,``6``,``2``,``3``};``        ``LLUtil llu = ``new` `LLUtil();``          ``Node head = llu.createLL(arr);``        ``System.out.println(``"Given Linked List"``);``        ``llu.printLL(head);``        ``head = deleteNodesOnRightSide(head);``          ``System.out.println(``"Modified Linked List"``);``          ``llu.printLL(head);``          ` `    ``}``    ` `  ``//Main function``     ``public` `static` `Node deleteNodesOnRightSide(Node head){``         ``if``(head == ``null` `|| head.next == ``null``) ``return` `head;``         ``Node nextNode = deleteNodesOnRightSide(head.next);` `         ``if``(nextNode.data > head.data) ``return` `nextNode;``         ``head.next = nextNode;` `         ``return` `head;``    ``}``}`

## Python3

 `#Python program for above approach` `# This class represents a single node``# in a linked list``class` `Node:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.``next` `=` `None` `#This is a utility class for linked list``class` `LLUtil:``    ` `      ``# This function creates a linked list from a``    ``# given array and returns head``    ``def` `createLL(``self``,arr):``        ` `        ``head ``=` `Node(arr[``0``])``        ``temp ``=` `head` `        ``newNode ``=` `None``        ``for` `i ``in` `range``(``1``, ``len``(arr)):``            ``newNode ``=` `Node(arr[i])``            ``temp.``next` `=` `newNode``            ``temp ``=` `temp.``next``        ``return` `head` `      ``#This function prints given linked list``    ``def` `printLL(``self``, head):``        ` `        ``while` `head !``=` `None``:``            ``print``(head.data, end``=``" "``)``            ``head ``=` `head.``next``        ``print``()` `#Main function``def` `deleteNodesOnRightSide(head):``    ``if` `head ``=``=` `None` `or` `head.``next` `=``=` `None``:``        ``return` `head``    ` `    ``nextNode ``=` `deleteNodesOnRightSide(head.``next``)` `    ``if` `nextNode.data > head.data:``        ``return` `nextNode``    ` `    ``head.``next` `=` `nextNode` `    ``return` `head` `if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``12``,``15``,``10``,``11``,``5``,``6``,``2``,``3``]``    ``llu ``=` `LLUtil()``    ``head ``=` `llu.createLL(arr)``    ``print``(``"Given Linked List"``)``    ``llu.printLL(head)``    ``head ``=` `deleteNodesOnRightSide(head)``    ``print``(``"Modified Linked List"``)``    ``llu.printLL(head)`

## C#

 `using` `System;` `// This class represents a single node``// in a linked list``class` `Node {``    ` `    ``public` `int` `data;``    ``public` `Node next;``    ` `    ``public` `Node(``int` `data){``        ``this``.data = data;``        ``this``.next = ``null``;``    ``}``}` `// This is a utility class for linked list``class` `LLUtil{``    ` `      ``// This function creates a linked list from a``    ``// given array and returns head``    ``public` `Node createLL(``int``[] arr){``        ` `        ``Node head = ``new` `Node(arr[0]);``        ``Node temp = head;``        ` `        ``Node newNode = ``null``;``        ``for``(``int` `i = 1; i < arr.Length; i++){``            ``newNode = ``new` `Node(arr[i]);``            ``temp.next = newNode;``            ``temp = temp.next;``        ``}``        ``return` `head;``    ``}``  ` `      ``//This function prints given linked list``      ``public` `void` `printLL(Node head){``        ` `        ``while``(head != ``null``){``            ``Console.Write(head.data + ``" "``);``            ``head = head.next;``        ``}``        ``Console.WriteLine();``    ``}``  ` `  ` `}` `class` `GFG {``    ``static` `void` `Main(``string``[] args) {``        ` `        ``int``[] arr = {12,15,10,11,5,6,2,3};``        ``LLUtil llu = ``new` `LLUtil();``        ``Node head = llu.createLL(arr);``        ``Console.WriteLine(``"Given Linked List"``);``        ``llu.printLL(head);``        ``head = deleteNodesOnRightSide(head);``        ``Console.WriteLine(``"Modified Linked List"``);``        ``llu.printLL(head);``    ``}``    ` `    ``//Main function``    ``public` `static` `Node deleteNodesOnRightSide(Node head){``        ``if``(head == ``null` `|| head.next == ``null``) ``return` `head;``        ``Node nextNode = deleteNodesOnRightSide(head.next);` `        ``if``(nextNode.data > head.data) ``return` `nextNode;``        ``head.next = nextNode;` `        ``return` `head;``    ``}``}`

## Javascript

 ``

Output

```Given Linked List
12 15 10 11 5 6 2 3