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.
Python3
class Node:
def __init__(self, data):
self.data = data
self.next = None
head = None
n = 0
sum = 0
def push(head_ref, new_data):
global head
new_node = Node(0)
new_node.data = new_data
new_node.next = head_ref
head_ref = new_node
head = head_ref
def sumOfLastN_Nodes(head):
global sum
global n
if (head == None):
return
sumOfLastN_Nodes(head.next)
if (n > 0) :
sum = sum + head.data
n = n - 1
def sumOfLastN_NodesUtil(head, n):
global sum
if (n <= 0):
return 0
sum = 0
sumOfLastN_Nodes(head)
return sum
head = None
push(head, 12)
push(head, 4)
push(head, 8)
push(head, 6)
push(head, 10)
n = 2
print("Sum of last " , n ,
" nodes = ",
sumOfLastN_NodesUtil(head, n))
|
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.
Python3
class Node:
def __init__(self, data):
self.data = data
self.next = None
head = None
n = 0
sum = 0
def push(head_ref, new_data):
global head
new_node = Node(0)
new_node.data = new_data
new_node.next = head_ref
head_ref = new_node
head = head_ref
def sumOfLastN_NodesUtil(head, n):
global sum
if (n <= 0):
return 0
st = []
sum = 0
while (head != None):
st.append(head.data)
head = head.next
while (n):
n -= 1
sum += st[0]
st.pop(0)
return sum
head = None
push(head, 12)
push(head, 4)
push(head, 8)
push(head, 6)
push(head, 10)
n = 2
print("Sum of last" , n ,
"nodes =",
sumOfLastN_NodesUtil(head, n))
|
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.
Python3
class Node:
def __init__(self, x):
self.data = x
self.next = None
head = None
def push(head_ref, new_data):
new_Node = Node(new_data)
new_Node.data = new_data
new_Node.next = head_ref
head_ref = new_Node
head = head_ref
return head
def reverseList():
global head;
current, prev, next = None,
None, None;
current = head;
prev = None;
while (current != None):
next = current.next;
current.next = prev;
prev = current;
current = next;
head = prev;
def sumOfLastN_NodesUtil(n):
if (n <= 0):
return 0;
reverseList();
sum = 0;
current = head;
while (current != None and n > 0):
sum += current.data;
current = current.next;
n -= 1;
reverseList();
return sum;
if __name__ == '__main__':
head = push(head, 12)
head = push(head, 4)
head = push(head, 8)
head = push(head, 6)
head = push(head, 10)
n = 2;
print("Sum of last ", n,
" Nodes = ",
sumOfLastN_NodesUtil(n));
|
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.
Python3
class Node:
def __init__(self, x):
self.data = x
self.next = None
head = None
def push(head_ref, new_data):
new_Node = Node(new_data)
new_Node.data = new_data
new_Node.next = head_ref
head_ref = new_Node
head = head_ref
return head
def sumOfLastN_NodesUtil(head, n):
if (n <= 0):
return 0
sum = 0
len = 0
temp = head
while (temp != None):
len += 1
temp = temp.next
c = len - n
temp = head
while (temp != None and c > 0):
temp = temp.next
c -= 1
while (temp != None):
sum += temp.data
temp = temp.next
return sum
if __name__ == '__main__':
head = push(head, 12)
head = push(head, 4)
head = push(head, 8)
head = push(head, 6)
head = push(head, 10)
n = 2
print("Sum of last ", n, " Nodes = ",
sumOfLastN_NodesUtil(head, n))
|
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.
Python3
class Node:
def __init__(self, x):
self.data = x
self.next = None
def push(head_ref,new_data):
new_node = Node(new_data)
new_node.next = head_ref
head_ref = new_node
return head_ref
def sumOfLastN_NodesUtil(head, n):
if (n <= 0):
return 0
sum = 0
temp = 0
ref_ptr = None
main_ptr = None
ref_ptr = main_ptr = head
while (ref_ptr != None and n):
sum += ref_ptr.data
ref_ptr = ref_ptr.next
n -= 1
while (ref_ptr != None):
temp += main_ptr.data
sum += ref_ptr.data
main_ptr = main_ptr.next
ref_ptr = ref_ptr.next
return (sum - temp)
if __name__ == '__main__':
head = None
head = push(head, 12)
head = push(head, 4)
head = push(head, 8)
head = push(head, 6)
head = push(head, 10)
n = 2
print("Sum of last ", n, " nodes = ",
sumOfLastN_NodesUtil(head, n))
|
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!