Sum of the nodes of a Singly Linked List

26 Oct, 2021
Given a singly linked list. The task is to find the sum of nodes of the given linked list. 
Task is to do A + B + C + D.
Examples:  
Input: 7->6->8->4->1
Output: 26
Sum of nodes:
7 + 6 + 8 + 4 + 1 = 26

Input: 1->7->3->9->11->5
Output: 36
 
Recursive Solution:  
Call a function by passing the head and variable to store the sum.Then recursively call the function by passing the next of current node and sum variable.Add the value of the current node to the sum.
Then recursively call the function by passing the next of current node and sum variable.Add the value of the current node to the sum.
Add the value of the current node to the sum.
Below is the implementation of above approach:  
C++
Java
Python3
C#
Javascript
// C++ implementation to find the sum of// nodes of the Linked List#include <bits/stdc++.h>using namespace std;  /* A Linked list node */struct Node {    int data;    struct Node* next;};  // function to insert a node at the// beginning of the linked listvoid push(struct Node** head_ref, int new_data){    /* allocate node */    struct Node* new_node = new Node;      /* put in the data */    new_node->data = new_data;      /* link the old list to the new node */    new_node->next = (*head_ref);      /* move the head to point to the new node */    (*head_ref) = new_node;}  // function to recursively find the sum of// nodes of the given linked listvoid sumOfNodes(struct Node* head, int* sum){    // if head = NULL    if (!head)        return;      // recursively traverse the remaining nodes    sumOfNodes(head->next, sum);      // accumulate sum    *sum = *sum + head->data;}  // utility function to find the sum of  nodesint sumOfNodesUtil(struct Node* head){      int sum = 0;      // find the sum of  nodes    sumOfNodes(head, &sum);      // required sum    return sum;}  // Driver program to test aboveint main(){    struct Node* head = NULL;      // create linked list 7->6->8->4->1    push(&head, 7);    push(&head, 6);    push(&head, 8);    push(&head, 4);    push(&head, 1);      cout << "Sum of nodes = "         << sumOfNodesUtil(head);    return 0;}
// Java implementation to find the sum of // nodes of the Linked List class GFG {      static int sum=0;      // A Linked list node /static class Node{     int data;     Node next; }   // function to insert a node at the // beginning of the linked list static Node push( Node head_ref, int new_data) {     // allocate node /    Node new_node = new Node();       // put in the data /    new_node.data = new_data;       // link the old list to the new node /    new_node.next = (head_ref);       // move the head to point to the new node /    (head_ref) = new_node;     return head_ref;}   // function to recursively find the sum of // nodes of the given linked list static void sumOfNodes( Node head) {     // if head = null     if (head == null)         return;       // recursively traverse the remaining nodes     sumOfNodes(head.next);       // accumulate sum     sum = sum + head.data; }   // utility function to find the sum of nodes static int sumOfNodesUtil( Node head) {       sum = 0;       // find the sum of nodes     sumOfNodes(head);       // required sum     return sum; }   // Driver program to test above public static void main(String args[]){     Node head = null;       // create linked list 7.6.8.4.1     head = push(head, 7);     head = push(head, 6);     head = push(head, 8);     head = push(head, 4);     head = push(head, 1);       System.out.println( "Sum of nodes = "        + sumOfNodesUtil(head)); } }  // This code is contributed by Arnab Kundu
# Python3 implementation to find the sum of # nodes of the Linked List import math  # class for a Sumclass Sum:    tsum = None  # A Linked list node class Node:    def __init__(self,data):        self.data = data        self.next = None  # function to insert a node at the # beginning of the linked list def push(head, data):    if not head:        return Node(data)      # put in the data     # and allocate node     new_node = Node(data)      # link the old list to the new node     new_node.next = head      # move the head to point    # to the new node     head = new_node    return head  # function to recursively find  # the sum of nodes of the given# linked list def sumOfNode(head, S):          # if head = NULL    if not head:        return          # recursively traverse the     # remaining nodes    sumOfNode(head.next, S)          # accumulate sum    S.tsum += head.data   # utility function to find # the sum of nodesdef sumOfNodesUtil(head):    S = Sum()    S.tsum = 0          # find the sum of nodes    sumOfNode(head, S)          # required sum    return S.tsum  # Driver Codeif __name__=='__main__':    head = None      # create linked list 7->6->8->4->1     head = push(head, 7)    head = push(head, 6)    head = push(head, 8)    head = push(head, 4)    head = push(head, 1)    print("Sum of Nodes = {}" .            format(sumOfNodesUtil(head)))  # This code is contributed # by Vikash Kumar 37
// C# implementation to find the sum of // nodes of the Linked List using System;  class GFG {     public static int sum = 0;               // A Linked list node /     public class Node     {         public int data;         public Node next;     }           // function to insert a node at the     // beginning of the linked list     static Node push(Node head_ref, int new_data)     {         // allocate node /         Node new_node = new Node();               // put in the data /         new_node.data = new_data;               // link the old list to the new node /         new_node.next = (head_ref);               // move the head to point to the new node /         (head_ref) = new_node;         return head_ref;     }           // function to recursively find the sum of     // nodes of the given linked list     static void sumOfNodes(Node head)     {         // if head = null         if (head == null)             return;               // recursively traverse the remaining nodes         sumOfNodes(head.next);               // accumulate sum         sum = sum + head.data;     }           // utility function to find the sum of nodes     static int sumOfNodesUtil(Node head)     {         sum = 0;               // find the sum of nodes         sumOfNodes(head);               // required sum         return sum;     }           // Driver program to test above     public static void Main(String[] args)     {         Node head = null;               // create linked list 7.6.8.4.1         head = push(head, 7);         head = push(head, 6);         head = push(head, 8);         head = push(head, 4);         head = push(head, 1);               Console.WriteLine("Sum of nodes = " +                           sumOfNodesUtil(head));     } }   // This code is contributed by Rajput-Ji
<script>  // JavaScript implementation to find the sum of // nodes of the Linked List     var sum = 0;      // A Linked list node /class Node {    constructor(val) {        this.data = val;        this.next = null;    }}        // function to insert a node at the    // beginning of the linked list    function push(head_ref , new_data) {        // allocate node /    var new_node = new Node();          // put in the data /        new_node.data = new_data;          // link the old list to the new node /        new_node.next = (head_ref);          // move the head to point to the new node /        (head_ref) = new_node;        return head_ref;    }      // function to recursively find the sum of    // nodes of the given linked list    function sumOfNodes(head) {        // if head = null        if (head == null)            return;          // recursively traverse the remaining nodes        sumOfNodes(head.next);          // accumulate sum        sum = sum + head.data;    }      // utility function to find the sum of nodes    function sumOfNodesUtil(head) {          sum = 0;          // find the sum of nodes        sumOfNodes(head);          // required sum        return sum;    }      // Driver program to test above              var head = null;          // create linked list 7.6.8.4.1        head = push(head, 7);        head = push(head, 6);        head = push(head, 8);        head = push(head, 4);        head = push(head, 1);          document.write("Sum of nodes = " +         sumOfNodesUtil(head));  // This code contributed by umadevi9616  </script>
Sum of nodes = 26
 
Time Complexity: O(N) , N is the number of nodes in a linked list. Auxiliary Space: O(N), only if the stack size is considered during recursive calls.Iterative Solution:  
Initialize a pointer ptr with the head of the linked list and a sum variable with 0.Start traversing the linked list using a loop until all the nodes get traversed.Add the value of current node to the sum i.e. sum += ptr -> data .Increment the pointer to the next node of linked list i.e. ptr = ptr ->next .Return the sum.
Initialize a pointer ptr with the head of the linked list and a sum variable with 0.
Start traversing the linked list using a loop until all the nodes get traversed.Add the value of current node to the sum i.e. sum += ptr -> data .Increment the pointer to the next node of linked list i.e. ptr = ptr ->next .
Add the value of current node to the sum i.e. sum += ptr -> data .
Increment the pointer to the next node of linked list i.e. ptr = ptr ->next .
Return the sum.
Below is the implementation of above approach:  
C++
Java
Python3
C#
Javascript
// C++ implementation to find the sum of// nodes of the Linked List#include <bits/stdc++.h>using namespace std;  /* A Linked list node */struct Node {    int data;    struct Node* next;};  // function to insert a node at the// beginning of the linked listvoid push(struct Node** head_ref, int new_data){    /* allocate node */    struct Node* new_node = new Node;      /* put in the data */    new_node->data = new_data;      /* link the old list to the new node */    new_node->next = (*head_ref);      /* move the head to point to the new node */    (*head_ref) = new_node;}  // function to find the sum of// nodes of the given linked listint sumOfNodes(struct Node* head){    struct Node* ptr = head;    int sum = 0;    while (ptr != NULL) {          sum += ptr->data;        ptr = ptr->next;    }      return sum;}  // Driver program to test aboveint main(){    struct Node* head = NULL;      // create linked list 7->6->8->4->1    push(&head, 7);    push(&head, 6);    push(&head, 8);    push(&head, 4);    push(&head, 1);      cout << "Sum of nodes = "         << sumOfNodes(head);    return 0;}
// Java implementation to find the sum of// nodes of the Linked List  class GFG {  static Node head;   /* A Linked list node */static class Node{    int data;    Node next;};  // function to insert a node at the// beginning of the linked list// Inserting node at the beginningstatic Node push(Node head_ref, int new_data){    /* allocate node */    Node new_node = new Node();          /* put in the data */    new_node.data = new_data;          /* link the old list to the new node */    new_node.next = head_ref;          /* move the head to point to the new node */    head_ref = new_node;    return head=head_ref;}  // function to find the sum of// nodes of the given linked liststatic int sumOfNodes( Node head){    Node ptr = head;    int sum = 0;    while (ptr != null)     {          sum += ptr.data;        ptr = ptr.next;    }      return sum;}  // Driver codepublic static void main(String[] args){    // create linked list 7.6.8.4.1    push(head, 7);    push(head, 6);    push(head, 8);    push(head, 4);    push(head, 1);      System.out.println("Sum of nodes = "        + sumOfNodes(head));}}  /* This code is contributed by PrinciRaj1992 */
# Python3 implementation to find the # sum of nodes of the Linked Listimport math   # A Linked list node class Node:     def __init__(self, data):         self.data = data         self.next = None  # function to insert a node at the# beginning of the linked listdef push(head_ref, new_data):          # allocate node     new_node = Node(new_data)      # put in the data     new_node.data = new_data      # link the old list to the new node     new_node.next = head_ref      # move the head to po to the new node     head_ref = new_node    return head_ref  # function to find the sum of# nodes of the given linked listdef sumOfNodes(head):    ptr = head    sum = 0    while (ptr != None):          sum = sum + ptr.data        ptr = ptr.next          return sum  # Driver Codeif __name__=='__main__':    head = None      # create linked list 7.6.8.4.1    head = push(head, 7)    head = push(head, 6)    head = push(head, 8)    head = push(head, 4)    head = push(head, 1)      print("Sum of nodes =",            sumOfNodes(head))      # This code is contributed by Srathore
// C# implementation to find the sum of // nodes of the Linked List using System;  class GFG {   static Node head;   /* A Linked list node */public class Node {     public int data;     public Node next; };   // function to insert a node at the // beginning of the linked list // Inserting node at the beginning static Node push(Node head_ref, int new_data) {     /* allocate node */    Node new_node = new Node();           /* put in the data */    new_node.data = new_data;           /* link the old list to the new node */    new_node.next = head_ref;           /* move the head to point to the new node */    head_ref = new_node;     return head=head_ref; }   // function to find the sum of // nodes of the given linked list static int sumOfNodes( Node head) {     Node ptr = head;     int sum = 0;     while (ptr != null)     {           sum += ptr.data;         ptr = ptr.next;     }       return sum; }   // Driver code public static void Main(String[] args) {     // create linked list 7.6.8.4.1     push(head, 7);     push(head, 6);     push(head, 8);     push(head, 4);     push(head, 1);       Console.WriteLine("Sum of nodes = "        + sumOfNodes(head)); } }   // This code is contributed by 29AjayKumar
<script>// javascript implementation to find the sum of// nodes of the Linked List    var head;      /* A Linked list node */     class Node {        constructor() {            this.data = 0;            this.next = null;        }    }         // function to insert a node at the    // beginning of the linked list    // Inserting node at the beginning    function push(head_ref , new_data) {        /* allocate node */var new_node = new Node();          /* put in the data */        new_node.data = new_data;          /* link the old list to the new node */        new_node.next = head_ref;          /* move the head to point to the new node */        head_ref = new_node;        return head = head_ref;    }      // function to find the sum of    // nodes of the given linked list    function sumOfNodes(head) {var ptr = head;        var sum = 0;        while (ptr != null) {              sum += ptr.data;            ptr = ptr.next;        }          return sum;    }      // Driver code              // create linked list 7.6.8.4.1        push(head, 7);        push(head, 6);        push(head, 8);        push(head, 4);        push(head, 1);          document.write("Sum of nodes = " + sumOfNodes(head));  // This code contributed by aashish1995</script>
Sum of nodes = 26
 
Time Complexity: O(N), N is the number of nodes in a linked list. Auxiliary Space: O(1) 
andrew1234
Vikash Kumar 37
Rajput-Ji
princiraj1992
29AjayKumar
sapnasingh4991
aashish1995
umadevi9616
simranarora5sos
Algorithms-Recursion
Data Structures-Linked List
Traversal
Linked List
Linked List
Traversal
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Data Structures
What is Data Structure: Types, Classifications and Applications
Implementing a Linked List in Java using Class
Find Length of a Linked List (Iterative and Recursive)
Queue - Linked List Implementation
Function to check if a singly linked list is palindrome
Write a function to get the intersection point of two Linked Lists
Remove duplicates from an unsorted linked list
Circular Linked List | Set 1 (Introduction and Applications)
Implement a stack using singly linked list