Remove all nodes from a Doubly Linked List containing Fibonacci numbers

// Java implementation to delete all Fibonacci nodes from
// the doubly linked list
import java.io.*;
import java.util.*;

class GFG {

    // Node of a doubly linked list
    class Node {
        int data;
        Node next, prev;
    }

    Node head = null;

    HashSet<Integer> hashset = new HashSet<Integer>();

    // Function to add a node at the beginning of the doubly
    // linked list.
    public Node push(int new_data)
    {

        // Allocate the node
        Node new_node = new Node();

        // Insert the data
        new_node.data = new_data;

        // Since we are adding at the beginning, prev is
        // always null
        new_node.prev = null;

        // Link the old list of the new node
        new_node.next = head;

        // change the prev of head node to new node
        if (head != null) {
            head.prev = new_node;
        }

        // move the head to point to the new node.
        head = new_node;
        return head;
    }

    // Function to find the largest nodes in the doubly
    // linked list.
    public int LargestInDLL()
    {

        // Initialize two pointer temp and max on to the
        // head node.
        Node max = head;
        Node temp = head;

        // Traverse the whole doubly linked list
        while (temp != null) {

            // If temp's data is greater than the max's
            // data, then max = temp and return max.data
            if (temp.data > max.data) {
                max = temp;
            }
            temp = temp.next;
        }
        return max.data;
    }

    // Function to create hashset table to check Fibonacci
    // numbers
    public void createHash(int maxElement)
    {
        int prev = 0, curr = 1;
        hashset.add(prev);
        hashset.add(curr);

        // Inserting the Fibonacci numbers until the maximum
        // element in the Linked List.
        while (curr <= maxElement) {
            int temp = curr + prev;
            hashset.add(temp);
            prev = curr;
            curr = temp;
        }
    }

    // Function to delete a node in a Doubly linked list.
    // delt -> pointer to node to be deleted.
    public void deleteNode(Node delt)
    {

        // Base case
        if (head == null || delt == null) {
            return;
        }

        // If the node to be deleted is head node
        if (head == delt) {
            head = delt.next;
        }

        // Change next only if node to be delete is not the
        // last node
        if (delt.next != null) {
            delt.next.prev = delt.prev;
        }

        // Change prev only if node to be deleted is not the
        // first node
        if (delt.prev != null) {
            delt.prev.next = delt.next;
        }
        return;
    }

    // Function to delete all fibonacci nodes from the
    // doubly linked list.
    public void deleteFibonacciNodes()
    {

        // Find the largest node value in doubly linked
        // list.
        int maxEle = LargestInDLL();

        createHash(maxEle);

        Node ptr = head;
        Node next = null;

        // Iterating through the linked list
        while (ptr != null) {
            next = ptr.next;
            // If node's data is fibonacci, delete node
            // 'ptr'
            if (hashset.contains(ptr.data)) {
                deleteNode(ptr);
            }
            ptr = next;
        }
    }

    // Function to print nodes in a given doubly linked
    // list.
    public void printList()
    {
        Node curr = head;
        while (curr != null) {
            System.out.print(curr.data + " ");
            curr = curr.next;
        }
        System.out.println();
    }

    public static void main(String[] args)
    {

        GFG l = new GFG();

        // Create the doubly linked list.

        // null<- 15 <-> 16 <-> 8 <-> 6 <-> 13 -> null

        l.push(13);
        l.push(6);
        l.push(8);
        l.push(16);
        l.push(15);

        System.out.print("Original List: ");
        l.printList();

        l.deleteFibonacciNodes();

        System.out.print("Modilied List: ");
        l.printList();
    }
}

// This code is contributed by lokeshmvs21