Given a singly linked list. The task is to find the sum of nodes of the given linked list.
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.
Below is the implementation of above approach:
C++
// 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;
} |
Java
// 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
# 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 |
C#
// 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 |
Javascript
<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> |
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:
- 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.
Below is the implementation of above approach:
C++
// 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;
} |
Java
// 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 */ |
Python3
# 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 |
C#
// 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 |
Javascript
<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> |
Output:
Sum of nodes = 26
Time Complexity: O(N), N is the number of nodes in a linked list.
Auxiliary Space: O(1)