Java Program To Delete Nodes Which Have A Greater Value On Right Side

// Java program to delete nodes which have 
// a greater value on right side
class LinkedList 
{
    // head of list
    Node head; 

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

// 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();
    }  
}

// Driver code
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;
    }
}