# Sum of all nodes in a doubly linked list divisible by a given number K

Given a doubly linked list containing N nodes and given a number K. The task is to find the sum of all such nodes which are divisible by K.

Examples:

```Input: List = 15 <=> 16 <=> 10 <=> 9 <=> 6 <=> 7 <=> 17
K = 3
Output: Sum = 30

Input: List = 5 <=> 3 <=> 6 <=> 8 <=> 4 <=> 1 <=> 2 <=> 9
K = 2
Output: Sum = 20
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: The idea is to traverse the doubly linked list and check the nodes one by one. If a node’s value is divisible by K then add that node value to otherwise continue this process while the end of the list is not reached.

Below is the implementation of the above approach:

## C++

 `// C++ implementation to add ` `// all nodes value which is ` `// divided by any given number K ` `#include ` ` `  `using` `namespace` `std; ` ` `  `// Node of the doubly linked list ` `struct` `Node { ` `    ``int` `data; ` `    ``Node *prev, *next; ` `}; ` ` `  `// function to insert a node at the beginning ` `// of the Doubly Linked List ` `void` `push(Node** head_ref, ``int` `new_data) ` `{ ` `    ``// allocate node ` `    ``Node* new_node = (Node*)``malloc``(``sizeof``(``struct` `Node)); ` ` `  `    ``// put in 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 off the new node ` `    ``new_node->next = (*head_ref); ` ` `  `    ``// change prev of head node to new node ` `    ``if` `((*head_ref) != NULL) ` `        ``(*head_ref)->prev = new_node; ` ` `  `    ``// move the head to point to the new node ` `    ``(*head_ref) = new_node; ` `} ` ` `  `// function to sum all the nodes ` `// from the doubly linked ` `// list that are divided by K ` `int` `sumOfNode(Node** head_ref, ``int` `K) ` `{ ` `    ``Node* ptr = *head_ref; ` `    ``Node* next; ` `    ``// variable sum=0 for add nodes value ` `    ``int` `sum = 0; ` `    ``// traves list till last node ` `    ``while` `(ptr != NULL) { ` `        ``next = ptr->next; ` `        ``// check is node value divided by K ` `        ``// if true then add in sum ` `        ``if` `(ptr->data % K == 0) ` `            ``sum += ptr->data; ` `        ``ptr = next; ` `    ``} ` `    ``// return sum of nodes which is divided by K ` `    ``return` `sum; ` `} ` ` `  `// Driver program to test above ` `int` `main() ` `{ ` `    ``// start with the empty list ` `    ``Node* head = NULL; ` ` `  `    ``// create the doubly linked list ` `    ``// 15 <-> 16 <-> 10 <-> 9 <-> 6 <-> 7 <-> 17 ` `    ``push(&head, 17); ` `    ``push(&head, 7); ` `    ``push(&head, 6); ` `    ``push(&head, 9); ` `    ``push(&head, 10); ` `    ``push(&head, 16); ` `    ``push(&head, 15); ` ` `  `    ``int` `sum = sumOfNode(&head, 3); ` `    ``cout << ``"Sum = "` `<< sum; ` `} `

## Java

 `// Java implementation to add ` `// all nodes value which is ` `// divided by any given number K ` ` `  `// Node of the doubly linked list ` `class` `Node { ` `    ``int` `data; ` `    ``Node next, prev; ` ` `  `    ``Node(``int` `d) { ` `        ``data = d; ` `        ``next = ``null``; ` `        ``prev = ``null``; ` `    ``} ` `} ` ` `  `class` `DLL  ` `{ ` `    ``// function to insert a node at the beginning ` `    ``// of the Doubly Linked List ` `    ``static` `Node push(Node head, ``int` `data) ` `    ``{ ` `         `  `        ``// allocate node ` `        ``Node newNode = ``new` `Node(data); ` `        ``newNode.next = head; ` `         `  `        ``// since we are adding at the beginning, ` `        ``// prev is always NULL ` `        ``newNode.prev = ``null``; ` `         `  `        ``// change prev of head node to new node ` `        ``if` `(head != ``null``) ` `            ``head.prev = newNode; ` `             `  `        ``// move the head to point to the new node ` `        ``head = newNode; ` ` `  `        ``return` `head; ` `    ``} ` ` `  `    ``// function to sum all the nodes ` `    ``// from the doubly linked ` `    ``// list that are divided by K ` `    ``static` `int` `sumOfNode(Node node, ``int` `K) { ` `        ``// variable sum=0 for add nodes value ` `        ``int` `sum = ``0``; ` `        ``// travese list till last node ` `        ``while` `(node != ``null``) { ` `            ``// check is node value divided by K ` `            ``// if true then add in sum ` `            ``if` `(node.data % K == ``0``) ` `                ``sum += node.data; ` `            ``node = node.next; ` `        ``} ` `        ``// return sum of nodes which is divided by K ` `        ``return` `sum; ` `    ``} ` ` `  `    ``// Driver program ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``// start with the empty list ` `        ``Node head = ``null``; ` ` `  `        ``// create the doubly linked list ` `        ``// 15 <-> 16 <-> 10 <-> 9 <-> 6 <-> 7 <-> 17 ` `        ``head = push(head, ``17``); ` `        ``head = push(head, ``7``); ` `        ``head = push(head, ``6``); ` `        ``head = push(head, ``9``); ` `        ``head = push(head, ``10``); ` `        ``head = push(head, ``16``); ` `        ``head = push(head, ``15``); ` `        ``int` `sum = sumOfNode(head, ``3``); ` `        ``System.out.println(``"Sum = "` `+ sum); ` `    ``} ` `} ` ` `  ` `  `// This code is contributed by Vivekkumar Singh `

## Python3

 `# Python3 implementation to add ` `# all nodes value which is ` `# divided by any given number K ` ` `  `# Node of the doubly linked list  ` `class` `Node:  ` `     `  `    ``def` `__init__(``self``, data):  ` `        ``self``.data ``=` `data  ` `        ``self``.prev ``=` `None` `        ``self``.``next` `=` `None` ` `  `# function to insert a node at the beginning ` `# of the Doubly Linked List ` `def` `push(head_ref, new_data): ` ` `  `    ``# allocate node ` `    ``new_node ``=``Node(``0``) ` ` `  `    ``# put in the data ` `    ``new_node.data ``=` `new_data ` ` `  `    ``# since we are adding at the beginning, ` `    ``# prev is always None ` `    ``new_node.prev ``=` `None` ` `  `    ``# link the old list off the new node ` `    ``new_node.``next` `=` `(head_ref) ` ` `  `    ``# change prev of head node to new node ` `    ``if` `((head_ref) !``=` `None``): ` `        ``(head_ref).prev ``=` `new_node ` ` `  `    ``# move the head to point to the new node ` `    ``(head_ref) ``=` `new_node ` `    ``return` `head_ref ` ` `  `# function to sum all the nodes ` `# from the doubly linked ` `# list that are divided by K ` `def` `sumOfNode(head_ref, K): ` ` `  `    ``ptr ``=` `head_ref ` `    ``next` `=` `None` `     `  `    ``# variable sum=0 for add nodes value ` `    ``sum` `=` `0` `     `  `    ``# traverse list till last node ` `    ``while` `(ptr !``=` `None``) : ` `        ``next` `=` `ptr.``next` `         `  `        ``# check is node value divided by K ` `        ``# if true then add in sum ` `        ``if` `(ptr.data ``%` `K ``=``=` `0``): ` `            ``sum` `+``=` `ptr.data ` `        ``ptr ``=` `next` `     `  `    ``# return sum of nodes which is divided by K ` `    ``return` `sum` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``:  ` ` `  `    ``# start with the empty list ` `    ``head ``=` `None` ` `  `    ``# create the doubly linked list ` `    ``# 15 <. 16 <. 10 <. 9 <. 6 <. 7 <. 17 ` `    ``head ``=` `push(head, ``17``) ` `    ``head ``=` `push(head, ``7``) ` `    ``head ``=` `push(head, ``6``) ` `    ``head ``=` `push(head, ``9``) ` `    ``head ``=` `push(head, ``10``) ` `    ``head ``=` `push(head, ``16``) ` `    ``head ``=` `push(head, ``15``) ` `  `  `    ``sum` `=` `sumOfNode(head, ``3``) ` `    ``print``(``"Sum ="``, ``sum``) ` ` `  `# This code is contributed by Arnab Kundu `

## C#

 `// C# implementation to add  ` `// all nodes value which is  ` `// divided by any given number K  ` `using` `System; ` ` `  `// Node of the doubly linked list  ` `public` `class` `Node  ` `{  ` `    ``public` `int` `data;  ` `    ``public` `Node next, prev;  ` ` `  `    ``public` `Node(``int` `d) ` `    ``{  ` `        ``data = d;  ` `        ``next = ``null``;  ` `        ``prev = ``null``;  ` `    ``}  ` `}  ` ` `  `class` `DLL  ` `{  ` `    ``// function to insert a node at the beginning  ` `    ``// of the Doubly Linked List  ` `    ``static` `Node push(Node head, ``int` `data)  ` `    ``{  ` `         `  `        ``// allocate node  ` `        ``Node newNode = ``new` `Node(data);  ` `        ``newNode.next = head;  ` `         `  `        ``// since we are adding at the beginning,  ` `        ``// prev is always NULL  ` `        ``newNode.prev = ``null``;  ` `         `  `        ``// change prev of head node to new node  ` `        ``if` `(head != ``null``)  ` `            ``head.prev = newNode;  ` `             `  `        ``// move the head to point to the new node  ` `        ``head = newNode;  ` ` `  `        ``return` `head;  ` `    ``}  ` ` `  `    ``// function to sum all the nodes  ` `    ``// from the doubly linked  ` `    ``// list that are divided by K  ` `    ``static` `int` `sumOfNode(Node node, ``int` `K) ` `    ``{  ` `        ``// variable sum=0 for add nodes value  ` `        ``int` `sum = 0;  ` `        ``// travese list till last node  ` `        ``while` `(node != ``null``) ` `        ``{  ` `            ``// check is node value divided by K  ` `            ``// if true then add in sum  ` `            ``if` `(node.data % K == 0)  ` `                ``sum += node.data;  ` `            ``node = node.next;  ` `        ``}  ` `        ``// return sum of nodes which is divided by K  ` `        ``return` `sum;  ` `    ``}  ` ` `  `    ``// Driver code  ` `    ``public` `static` `void` `Main(String []args)  ` `    ``{  ` `        ``// start with the empty list  ` `        ``Node head = ``null``;  ` ` `  `        ``// create the doubly linked list  ` `        ``// 15 <-> 16 <-> 10 <-> 9 <-> 6 <-> 7 <-> 17  ` `        ``head = push(head, 17);  ` `        ``head = push(head, 7);  ` `        ``head = push(head, 6);  ` `        ``head = push(head, 9);  ` `        ``head = push(head, 10);  ` `        ``head = push(head, 16);  ` `        ``head = push(head, 15);  ` `        ``int` `sum = sumOfNode(head, 3);  ` `        ``Console.WriteLine(``"Sum = "` `+ sum);  ` `    ``}  ` `}  ` ` `  `// This code is contributed by Arnab Kundu `

Output:

```Sum = 30
```

Time Complexity: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.