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

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 sum otherwise continue this process while the end of the list is not reached.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation to add
// all nodes value which is
// divided by any given number K
#include <bits/stdc++.h>
  
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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.