# Delete all the nodes from the list which are divisible by any given number K

Given a Linked List and a key K. The task is to write a program to delete all the nodes from the list that are divisible by K.

Examples:

Input : 12->15->9->11->5->6->7
K = 3
Output :  11 -> 5 -> 7

Input :13->4->16->9->22->45->5->16->6
K = 4
Output : 13 -> 9 -> 22 -> 45 -> 5 -> 6

Approach:

The approach to solving this problem is similar to deleting all nodes from the list which are lesser than the given key.

There are two possible cases:

1. Head node holds a value divisible by K: First check for all occurrences at head node which are divisible by K, delete them and change the head node appropriately.
2. Some intermediate node holds value divisible by k: Start traversing from head and check if current nodeâ€™s value is divisible by K. If yes then delete that node and move forward in the list.

Below is the implementation of the above approach:

## C++

 `// C++ program to delete all the nodes from the list``// that are divisible by  the specified value K``#include ` `using` `namespace` `std;` `// Tree Node``struct` `Node {``    ``int` `data;``    ``Node* next;``};` `// Function to create a new node``Node* getNode(``int` `data)``{``    ``Node* newNode = ``new` `Node;``    ``newNode->data = data;``    ``newNode->next = NULL;``    ``return` `newNode;``}` `// Function to delete all the nodes from the list``// that divisible by the specified value K``void` `deleteDivisibleNodes(Node** head_ref, ``int` `K)``{``    ``Node *temp = *head_ref, *prev;` `    ``// If head node itself holds the value divisible by K``    ``while` `(temp != NULL && temp->data % K == 0) {``        ``*head_ref = temp->next; ``// Changed head``        ``free``(temp); ``// free old head``        ``temp = *head_ref; ``// Change temp``    ``}` `    ``// Delete occurrences other than head``    ``while` `(temp != NULL) {` `        ``// Search for the node to be deleted,``        ``// keep track of the previous node as we``        ``// need to change 'prev->next'``        ``while` `(temp != NULL && temp->data % K != 0) {``            ``prev = temp;``            ``temp = temp->next;``        ``}` `        ``// If required value node was not present``        ``// in linked list``        ``if` `(temp == NULL)``            ``return``;` `        ``// Unlink the node from linked list``        ``prev->next = temp->next;` `        ``delete` `temp; ``// Free memory` `        ``// Update Temp for next iteration of``        ``// outer loop``        ``temp = prev->next;``    ``}``}` `// function to a print a linked list``void` `printList(Node* head)``{``    ``while` `(head) {``        ``cout << head->data << ``" "``;``        ``head = head->next;``    ``}``}` `// Driver code``int` `main()``{``    ``// Create list: 12->15->9->11->5->6->7``    ``Node* head = getNode(12);``    ``head->next = getNode(15);``    ``head->next->next = getNode(9);``    ``head->next->next->next = getNode(11);``    ``head->next->next->next->next = getNode(5);``    ``head->next->next->next->next->next = getNode(6);``    ``head->next->next->next->next->next->next = getNode(7);``    ``int` `K = 3;` `    ``cout << ``"Initial List: "``;``    ``printList(head);` `    ``deleteDivisibleNodes(&head, K);` `    ``cout << ``"\nFinal List: "``;``    ``printList(head);` `    ``return` `0;``}`

## Java

 `// Java program to delete all the nodes from the list``// that are divisible by the specified value K``import` `java.util.*;` `class` `GFG``{` `// Tree Node``static` `class` `Node``{``    ``int` `data;``    ``Node next;``};` `// Function to create a new node``static` `Node getNode(``int` `data)``{``    ``Node newNode = ``new` `Node();``    ``newNode.data = data;``    ``newNode.next = ``null``;``    ``return` `newNode;``}` `// Function to delete all the nodes from the list``// that divisible by the specified value K``static` `Node deleteDivisibleNodes(Node head_ref, ``int` `K)``{``    ``Node temp = head_ref, prev = ``null``;` `    ``// If head node itself holds the value divisible by K``    ``while` `(temp != ``null` `&& temp.data % K == ``0``) ``    ``{``        ``head_ref = temp.next; ``// Changed head``        ``//free(temp); // free old head``        ``temp = head_ref; ``// Change temp``    ``}` `    ``// Delete occurrences other than head``    ``while` `(temp != ``null``) ``    ``{` `        ``// Search for the node to be deleted,``        ``// keep track of the previous node as we``        ``// need to change 'prev.next'``        ``while` `(temp != ``null` `&& temp.data % K != ``0``) ``        ``{``            ``prev = temp;``            ``temp = temp.next;``        ``}` `        ``// If required value node was not present``        ``// in linked list``        ``if` `(temp == ``null``)``            ``return` `head_ref;` `        ``// Unlink the node from linked list``        ``prev.next = temp.next;` `        ``//delete temp; // Free memory` `        ``// Update Temp for next iteration of``        ``// outer loop``        ``temp = prev.next;``    ``}``    ``return` `null``;``}` `// function to a print a linked list``static` `void` `printList(Node head)``{``    ``while` `(head != ``null``)``    ``{``        ``System.out.print(head.data + ``" "``);``        ``head = head.next;``    ``}``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``// Create list: 12->15->9->11->5->6->7``    ``Node head = getNode(``12``);``    ``head.next = getNode(``15``);``    ``head.next.next = getNode(``9``);``    ``head.next.next.next = getNode(``11``);``    ``head.next.next.next.next = getNode(``5``);``    ``head.next.next.next.next.next = getNode(``6``);``    ``head.next.next.next.next.next.next = getNode(``7``);``    ``int` `K = ``3``;` `    ``System.out.print(``"Initial List: "``);``    ``printList(head);` `    ``head = deleteDivisibleNodes(head, K);` `    ``System.out.print(``"\nFinal List: "``);``    ``printList(head);``}``}` `// This code is contributed by PrinciRaj1992`

## Python3

 `# Python3 program to delete all the``# nodes from the list that are ``# divisible by the specified value K` `# Node class ``class` `Node: ``    ` `    ``# Function to initialize the node object ``    ``def` `__init__(``self``, data): ``        ` `        ``self``.data ``=` `data ``        ``self``.``next` `=` `None``    ` `# Linked List Class``class` `LinkedList:` `    ``# Function to initialize the``    ``# LinkedList class.``    ``def` `__init__(``self``):` `        ``# Initialize head as None``        ``self``.head ``=` `None` `    ``# This Method insert a new node ``    ``# at the End of the list``    ``def` `push(``self``, new_data):` `        ``# Taking a pointer to iterate``        ``ptr ``=` `self``.head` `        ``# Making a new node with``        ``# given data as it's element``        ``new_node ``=` `Node(new_data)` `        ``# assigning the first node to``        ``# head if list is empty or DNE``        ``if``(ptr ``=``=` `None``):``            ``self``.head ``=` `new_node` `        ``# If list exits then..``        ``else``:``            ` `            ``# Iterating to the last``            ``# node of the list``            ``while``(ptr.``next` `!``=` `None``):``                ``ptr ``=` `ptr.``next` `            ``# Attaching new node at``            ``# the end of list``            ``ptr.``next` `=` `new_node` `    ``# Method to delete Nodes divisible``    ``# by given integer.``    ``def` `deleteDivisibleNodes(``self``, K):` `        ``# Declaring a temporary object``        ``# containing address of head``        ``temp ``=` `self``.head` `        ``# Deleting the first node if it's``        ``# data is divisible by given integer``        ``# repeat till first node gets``        ``# indivisible.``        ``while``(temp !``=` `None` `and``             ``(temp.data ``%` `K) ``=``=` `0``):``            ``self``.head ``=` `temp.``next``            ``del``(temp)``            ``temp ``=` `self``.head` `        ``# Now iterating through each node``        ``# of the list.``        ``while``(temp !``=` `None``):` `            ``# Checking if data in current node is``            ``# divisible by given element and move``            ``# to next node till it gets not divisible.``            ``while``(temp !``=` `None` `and``                 ``(temp.data ``%` `K) !``=` `0``):``                ``prev ``=` `temp``                ``temp ``=` `temp.``next` `            ``# Returning if list ends``            ``if``(temp ``=``=` `None``):``                ``return` `            ``# Else storing address of next node``            ``# in next of previous node``            ``prev.``next` `=` `temp.``next` `            ``# And deleting the current Node``            ``del``(temp)` `            ``# Then move to next node and repeat``            ``# the loop till list ends.``            ``temp ``=` `prev.``next` `    ``# Method to print the linked list``    ``def` `printList(``self``):``        ` `        ``ptr ``=` `self``.head``        ` `        ``while``(ptr !``=` `None``):``            ``x ``=` `ptr.data``            ``print``(x, ``' '``, end ``=` `'')``            ``ptr ``=` `ptr.``next``            ` `        ``print``()` `# Driver Code``if` `__name__``=``=``'__main__'``:` `    ``# Start with empty list``    ``head ``=` `LinkedList()` `    ``# Create the linked list Adding``    ``# a new node at End of the list``    ``head.push(``12``)``    ``head.push(``15``) ``    ``head.push(``9``)``    ``head.push(``11``)``    ``head.push(``5``)``    ``head.push(``6``)``    ``head.push(``7``)` `    ``print``(``"Initial List: "``, end ``=` `'')``    ``head.printList()` `    ``K ``=` `3``    ``head.deleteDivisibleNodes(K)` `    ``print``(``"Final List: "``, end ``=` `'')``    ``head.printList()` `# This code is contributed by Amit Mangal`

## C#

 `// C# program to delete all the nodes ``// from the list that are divisible ``// by the specified value K``using` `System;` `class` `GFG``{` `// Tree Node``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node next;``};` `// Function to create a new node``static` `Node getNode(``int` `data)``{``    ``Node newNode = ``new` `Node();``    ``newNode.data = data;``    ``newNode.next = ``null``;``    ``return` `newNode;``}` `// Function to delete all the nodes``// from the list that divisible by``// the specified value K``static` `Node deleteDivisibleNodes(Node head_ref, ``                                         ``int` `K)``{``    ``Node temp = head_ref, prev = ``null``;` `    ``// If head node itself holds``    ``// the value divisible by K``    ``while` `(temp != ``null` `&& ``           ``temp.data % K == 0) ``    ``{``        ``head_ref = temp.next; ``// Changed head``        ``//free(temp); // free old head``        ``temp = head_ref; ``// Change temp``    ``}` `    ``// Delete occurrences other than head``    ``while` `(temp != ``null``) ``    ``{` `        ``// Search for the node to be deleted,``        ``// keep track of the previous node as we``        ``// need to change 'prev.next'``        ``while` `(temp != ``null` `&&``               ``temp.data % K != 0) ``        ``{``            ``prev = temp;``            ``temp = temp.next;``        ``}` `        ``// If required value node ``        ``// was not present in linked list``        ``if` `(temp == ``null``)``            ``return` `head_ref;` `        ``// Unlink the node from linked list``        ``prev.next = temp.next;` `        ``//delete temp; // Free memory` `        ``// Update Temp for next iteration of``        ``// outer loop``        ``temp = prev.next;``    ``}``    ``return` `null``;``}` `// function to a print a linked list``static` `void` `printList(Node head)``{``    ``while` `(head != ``null``)``    ``{``        ``Console.Write(head.data + ``" "``);``        ``head = head.next;``    ``}``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``// Create list: 12->15->9->11->5->6->7``    ``Node head = getNode(12);``    ``head.next = getNode(15);``    ``head.next.next = getNode(9);``    ``head.next.next.next = getNode(11);``    ``head.next.next.next.next = getNode(5);``    ``head.next.next.next.next.next = getNode(6);``    ``head.next.next.next.next.next.next = getNode(7);``    ``int` `K = 3;` `    ``Console.Write(``"Initial List: "``);``    ``printList(head);` `    ``head = deleteDivisibleNodes(head, K);` `    ``Console.Write(``"\nFinal List: "``);``    ``printList(head);``}``}` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output
```Initial List: 12 15 9 11 5 6 7
Final List: 11 5 7 ```

Complexity Analysis:

• Time Complexity: O(N), Linked List traversal takes O(N) time.
• Auxiliary Space: O(1), because no extra space is being used.

Previous
Next