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 <bits/stdc++.h>
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 <stdio.h>
#include <stdlib.h>

/* 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

<script>
// javascript program to delete nodes which have a greater value on
// right side
    var head; // head of list

    /* Linked list Node */
    class Node {
        constructor(val) {
            this.data = val;
            this.next = null;
        }
    }


    /*
     * Deletes nodes which have a node with greater value node on left side
     */
    function 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
     */
    function _delLesserNodes() {
        var current = head;

        /* Initialise max */
        var maxnode = head;
        var 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  */
    function push(new_data) {
        /*
         * 1 & 2: Allocate the Node & Put in the data
         */
        var 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 */
    function reverseList() {
        var current = head;
        var prev = null;
        var next;
        while (current != null) {
            next = current.next;
            current.next = prev;
            prev = current;
            current = next;
        }
        head = prev;
    }

    /* Function to print linked list */
    function printList() {
        var temp = head;
        while (temp != null) {
            document.write(temp.data + " ");
            temp = temp.next;
        }
        document.write();
    }

    /* Driver program to test above functions */


        /*
         * Constructed Linked List is 12->15->10->11-> 5->6->2->3
         */
        push(3);
        push(2);
        push(6);
        push(5);
        push(11);
        push(10);
        push(15);
        push(12);

        document.write("Given Linked List<br/>");
        printList();

        delLesserNodes();

        document.write("<br/>Modified Linked List<br/>");
        printList();

// This code contributed by aashish1995
</script>

Output

Given Linked List 
 12 15 10 11 5 6 2 3
Modified Linked List 
 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 <bits/stdc++.h>
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

<script>
// javascript program for above approach// This class represents a single node
// in a linked list
class Node {
    constructor(val) {
        this.data = val;
        this.next = null;
    }
}

// This is a utility class for linked list


    // This function creates a linked list from a
    // given array and returns head
     function createLL(arr) {

var head = new Node(arr[0]);
var temp = head;

var newNode = null;
        for (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
     function printLL(head) {

        while (head != null) {
            document.write(head.data + " ");
            head = head.next;
        }
        document.write("<br/>");
    }






    // Main function
    function deleteNodesOnRightSide(head) {
        if (head == null || head.next == null)
            return head;
var nextNode = deleteNodesOnRightSide(head.next);

        if (nextNode.data > head.data)
            return nextNode;
        head.next = nextNode;

        return head;
}
var arr = [ 12,15,10,11,5,6,2,3];

var head = createLL(arr);
        document.write("Given Linked List<br/>");
        printLL(head);
        head = deleteNodesOnRightSide(head);
        document.write("<br/>Modified Linked List<br/>");
        printLL(head);

// This code contributed by aashish1995
</script>

Output

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

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

Source: 

https://www.geeksforgeeks.org/forum/topic/amazon-interview-question-for-software-engineerdeveloper-about-linked-lists-6

Please write comments if you find the above code/algorithm incorrect, or find other ways to solve the same problem.