Sum of the nodes of a Singly Linked List

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.

Below is the implementation of above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 list
void 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 list
void 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  nodes
int sumOfNodesUtil(struct Node* head)
{
  
    int sum = 0;
  
    // find the sum of  nodes
    sumOfNodes(head, &sum);
  
    // required sum
    return sum;
}
  
// Driver program to test above
int 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation to find the sum of 
# nodes of the Linked List 
import math
  
# class for a Sum
class 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 nodes
def sumOfNodesUtil(head):
    S = Sum()
    S.tsum = 0
      
    # find the sum of nodes
    sumOfNode(head, S)
      
    # required sum
    return S.tsum
  
# Driver Code
if __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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output:

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:

  1. Initialise a pointer ptr with the head of the linked list and a sum variable with 0.
  2. 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 .
  3. Return the sum.

Below is the implementation of above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 list
void 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 list
int 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 above
int 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 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);
  
    System.out.println("Sum of nodes = "
        + sumOfNodes(head));
}
}
  
/* This code is contributed by PrinciRaj1992 */

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation to find the 
# sum of nodes of the Linked List
import 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 list
def 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 list
def sumOfNodes(head):
    ptr = head
    sum = 0
    while (ptr != None):
  
        sum = sum + ptr.data
        ptr = ptr.next
      
    return sum
  
# Driver Code
if __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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output:

Sum of nodes = 26

Time Complexity: O(N) , N is the number of nodes in a linked list.
Auxiliary Space: O(1)



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.