Javascript Program To Find The Sum Of Last N Nodes Of The Given Linked List
Last Updated :
13 Jan, 2022
Given a linked list and a number n. Find the sum of the last n nodes of the linked list.
Constraints: 0 <= n <= number of nodes in the linked list.
Examples:Â Â
Input : 10->6->8->4->12, n = 2
Output : 16
Sum of last two nodes:
12 + 4 = 16
Input : 15->7->9->5->16->14, n = 4
Output : 44
Method 1: (Recursive approach using system call stack)Â
Recursively traverse the linked list up to the end. Now during the return from the function calls, add up the last n nodes. The sum can be accumulated in some variable passed by reference to the function or to some global variable.
Javascript
<script>
class Node
{
constructor()
{
this .data;
this .next;
}
}
let head;
let n, sum;
function push(head_ref,new_data)
{
let new_node = new Node();
new_node.data = new_data;
new_node.next = head_ref;
head_ref = new_node;
head = head_ref;
}
function sumOfLastN_Nodes(head)
{
if (head == null )
return ;
sumOfLastN_Nodes(head.next);
if (n > 0)
{
sum = sum + head.data;
--n;
}
}
function sumOfLastN_NodesUtil(head,n)
{
if (n <= 0)
return 0;
sum = 0;
sumOfLastN_Nodes(head);
return sum;
}
head = null ;
push(head, 12);
push(head, 4);
push(head, 8);
push(head, 6);
push(head, 10);
n = 2;
document.write( "Sum of last " + n +
" nodes = " +
sumOfLastN_NodesUtil(head, n));
</script>
|
Output:Â Â
Sum of last 2 nodes = 16
Time Complexity: O(n), where n is the number of nodes in the linked list.Â
Auxiliary Space: O(n), if system call stack is being considered.
Method 2 (Iterative approach using user-defined stack)Â
It is an iterative procedure to the recursive approach explained in Method 1 of this post. Traverses the nodes from left to right. While traversing pushes the nodes to a user-defined stack. Then pops the top n values from the stack and adds them.
Javascript
<script>
class Node
{
constructor()
{
let data,next;
}
}
function push(head_ref,new_data)
{
let new_node = new Node();
new_node.data = new_data;
new_node.next = head_ref;
head_ref = new_node;
return head_ref;
}
function sumOfLastN_NodesUtil(head,n)
{
if (n <= 0)
return 0;
let st = [];
let sum = 0;
while (head != null )
{
st.push(head.data);
head = head.next;
}
while (n-- >0)
{
sum += st[st.length-1];
st.pop();
}
return sum;
}
let head = null ;
head = push(head, 12);
head = push(head, 4);
head = push(head, 8);
head = push(head, 6);
head = push(head, 10);
let n = 2;
document.write( "Sum of last " + n+ " nodes = "
+ sumOfLastN_NodesUtil(head, n));
</script>
|
Output:Â Â
Sum of last 2 nodes = 16
Time Complexity: O(n), where n is the number of nodes in the linked list.Â
Auxiliary Space: O(n), stack size
Method 3 (Reversing the linked list)Â
Following are the steps:Â Â
- Reverse the given linked list.
- Traverse the first n nodes of the reversed linked list.
- While traversing add them.
- Reverse the linked list back to its original order.
- Return the added sum.
Javascript
<script>
class Node {
constructor() {
this .data = 0;
this .next = null ;
}
}
var head;
function push(head_ref , new_data)
{
var new_node = new Node();
new_node.data = new_data;
new_node.next = head_ref;
head_ref = new_node;
head=head_ref;
}
function reverseList(head_ref)
{
var current, prev, next;
current = head_ref;
prev = null ;
while (current != null )
{
next = current.next;
current.next = prev;
prev = current;
current = next;
}
head_ref = prev;
head = head_ref;
}
function sumOfLastN_NodesUtil(n)
{
if (n <= 0)
return 0;
reverseList(head);
var sum = 0;
var current = head;
while (current != null && n-- >0)
{
sum += current.data;
current = current.next;
}
reverseList(head);
return sum;
}
push(head, 12);
push(head, 4);
push(head, 8);
push(head, 6);
push(head, 10);
var n = 2;
document.write( "Sum of last " + n + " nodes = "
+ sumOfLastN_NodesUtil(n));
</script>
|
Output:Â
Sum of last 2 nodes = 16
Time Complexity: O(n), where n is the number of nodes in the linked list.Â
Auxiliary Space: O(1)
Method 4 (Using the length of linked list)Â
Following are the steps:Â
- Calculate the length of the given Linked List. Let it be len.
- First, traverse the (len – n) nodes from the beginning.
- Then traverse the remaining n nodes and while traversing add them.
- Return the added sum.
Javascript
<script>
class Node {
constructor() {
this .data = 0;
this .next = null ;
}
}
var head;
function push( head_ref , new_data)
{
new_node = new Node();
new_node.data = new_data;
new_node.next = head_ref;
head_ref = new_node;
head = head_ref;
}
function sumOfLastN_NodesUtil( head , n)
{
if (n <= 0)
return 0;
var sum = 0, len = 0;
temp = head;
while (temp != null ) {
len++;
temp = temp.next;
}
var c = len - n;
temp = head;
while (temp != null && c-- > 0) {
temp = temp.next;
}
while (temp != null ) {
sum += temp.data;
temp = temp.next;
}
return sum;
}
push(head, 12);
push(head, 4);
push(head, 8);
push(head, 6);
push(head, 10);
var n = 2;
document.write( "Sum of last " + n
+ " nodes = " + sumOfLastN_NodesUtil(head, n));
</script>
|
Output:Â Â
Sum of last 2 nodes = 16
Time Complexity: O(n), where n is the number of nodes in the linked list.Â
Auxiliary Space: O(1)
Method 5 (Use of two pointers requires single traversal)Â
Maintain two pointers – reference pointer and main pointer. Initialize both reference and main pointers to head. First, move reference pointer to n nodes from head and while traversing accumulate node’s data to some variable, say sum. Now move both pointers simultaneously until the reference pointer reaches the end of the list and while traversing accumulate all node’s data to sum pointed by the reference pointer and accumulate all node’s data to some variable, say, temp, pointed by the main pointer. Now, (sum – temp) is the required sum of the last n nodes.
Javascript
<script>
class Node
{
constructor()
{
let node,next;
}
}
let head;
function printList(start)
{
let temp = start;
while (temp != null )
{
document.write(temp.data + " " );
temp = temp.next;
}
document.write( "<br>" );
}
function push(start,info)
{
let node = new Node();
node.data = info;
node.next = start;
head = node;
}
function sumOfLastN_NodesUtil(head,n)
{
if (n <= 0)
return 0;
let sum = 0, temp = 0;
let ref_ptr, main_ptr;
ref_ptr = main_ptr = head;
while (ref_ptr != null && (n--) > 0)
{
sum += ref_ptr.data;
ref_ptr = ref_ptr.next;
}
while (ref_ptr != null )
{
temp += main_ptr.data;
sum += ref_ptr.data;
main_ptr = main_ptr.next;
ref_ptr = ref_ptr.next;
}
return (sum - temp);
}
head = null ;
push(head, 12);
push(head, 4);
push(head, 8);
push(head, 6);
push(head, 10);
let n = 2;
document.write( "Sum of last " + n +
" nodes = " + sumOfLastN_NodesUtil(head, n));
</script>
|
Output:Â
Sum of last 2 nodes = 16
Time Complexity: O(n), where n is the number of nodes in the linked list.Â
Auxiliary Space: O(1)
Please refer complete article on Find the sum of last n nodes of the given Linked List for more details!
Share your thoughts in the comments
Please Login to comment...