# Delete continuous nodes with sum K from a given linked list

• Difficulty Level : Hard
• Last Updated : 17 Oct, 2022

Given a singly linked list and an integer K, the task is to remove all the continuous set of nodes whose sum is K from the given linked list. Print the updated linked list after the removal. If no such deletion can occur, print the original Linked list.

Examples:

Input: Linked List: 1 -> 2 -> -3 -> 3 -> 1, K = 3

Output: -3 -> 1

Explanation:

The nodes with continuous sum 3 are:

1) 1 -> 2

2) 3

Therefore, after removing these chain of nodes Linked List becomes: -3-> 1

Input: Linked List: 1 -> 1 -> -3 -> -3 -> -2, K = 5
Output: 1 -> 1 -> -3 -> -3 -> -2
Explanation:
No continuous nodes exits with sum K

Approach:

1. Append Node with value zero at the starting of the linked list.
2. Traverse the given linked list.
3. During traversal store the sum of the node value till that node with the reference of the current node in an unordered_map.
4. If there is Node with value (sum – K) present in the unordered_map then delete all the nodes from the node corresponding to value (sum – K) stored in map to the current node and update the sum as (sum – K).
5. If there is no Node with value (sum – K) present in the unordered_map, then stored the current sum with node in the map.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// A Linked List Node``struct` `ListNode {``    ``int` `val;``    ``ListNode* next;` `    ``// Constructor``    ``ListNode(``int` `x)``        ``: val(x)``        ``, next(NULL)``    ``{``    ``}``};` `// Function to create Node``ListNode* getNode(``int` `data)``{``    ``ListNode* temp;``    ``temp = (ListNode*)``malloc``(``sizeof``(ListNode));``    ``temp->val = data;``    ``temp->next = NULL;``    ``return` `temp;``}` `// Function to print the Linked List``void` `printList(ListNode* head)``{``    ``while` `(head->next) {``        ``cout << head->val << ``" -> "``;``        ``head = head->next;``    ``}``    ``cout << head->val;``}` `// Function that removes continuous nodes``// whose sum is K``ListNode* removeZeroSum(ListNode* head, ``int` `K)``{``    ``// Root node initialise to 0``    ``ListNode* root = ``new` `ListNode(0);` `    ``// Append at the front of the given``    ``// Linked List``    ``root->next = head;` `    ``// Map to store the sum and reference``    ``// of the Node``    ``unordered_map<``int``, ListNode*> umap;` `    ``umap[0] = root;` `    ``// To store the sum while traversing``    ``int` `sum = 0;` `    ``// Traversing the Linked List``    ``while` `(head != NULL) {` `        ``// Find sum``        ``sum += head->val;` `        ``// If found value with (sum - K)``        ``if` `(umap.find(sum - K) != umap.end()) {` `            ``ListNode* prev = umap[sum - K];``            ``ListNode* start = prev;`  `            `  `            ``// Update sum``            ``sum = sum - K;``            ``int` `aux = sum;``            ``// Traverse till current head``            ``while` `(prev != head) {``                ``prev = prev->next;``                ``aux += prev->val;``                ``if` `(prev != head) {``                    ``umap.erase(aux);``                ``}``            ``}` `            ``// Update the start value to``            ``// the next value of current head``            ``start->next = head->next;``        ``}` `        ``// If (sum - K) value not found``        ``else` `if` `(umap.find(sum) == umap.end()) {``            ``umap[sum] = head;``        ``}` `        ``head = head->next;``    ``}` `    ``// Return the value of updated``    ``// head node``    ``return` `root->next;``}` `// Driver Code``int` `main()``{``    ``// head Node``    ``ListNode* head;` `    ``// Create Linked List``    ``head = getNode(1);``    ``head->next = getNode(2);``    ``head->next->next = getNode(-3);``    ``head->next->next->next = getNode(3);``    ``head->next->next->next->next = getNode(1);` `    ``// Given sum K``    ``int` `K = 5;` `    ``// Function call to get head node``    ``// of the updated Linked List``    ``head = removeZeroSum(head, K);` `    ``// Print the updated Linked List``    ``if` `(head != NULL)``        ``printList(head);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.util.*;` `// A Linked List Node``class` `ListNode {``    ``int` `val;``    ``ListNode next;` `    ``// Constructor``    ``ListNode(``int` `val)``    ``{``        ``this``.val = val;``        ``this``.next = ``null``;``    ``}``}` `class` `GFG {` `    ``// Function to create Node``    ``static` `ListNode getNode(``int` `data)``    ``{``        ``ListNode temp = ``new` `ListNode(data);``        ``return` `temp;``    ``}` `    ``// Function to print the Linked List``    ``static` `void` `printList(ListNode head)``    ``{``        ``while` `(head.next != ``null``) {``            ``System.out.print(head.val + ``" -> "``);``            ``head = head.next;``        ``}``        ``System.out.print(head.val);``    ``}` `    ``// Function that removes continuous nodes``    ``// whose sum is K``    ``static` `ListNode removeZeroSum(ListNode head, ``int` `K)``    ``{``        ``// Root node initialise to 0``        ``ListNode root = ``new` `ListNode(``0``);` `        ``// Append at the front of the given``        ``// Linked List``        ``root.next = head;` `        ``// Map to store the sum and reference``        ``// of the Node``        ``Map umap``            ``= ``new` `HashMap();` `        ``umap.put(``0``, root);` `        ``// To store the sum while traversing``        ``int` `sum = ``0``;` `        ``// Traversing the Linked List``        ``while` `(head != ``null``) {` `            ``// Find sum``            ``sum += head.val;` `            ``// If found value with (sum - K)``            ``if` `(umap.containsKey(sum - K)) {` `                ``ListNode prev = umap.get(sum - K);``                ``ListNode start = prev;` `                ``// Delete all the node``                ``// traverse till current node``                ``int` `aux = sum;` `                ``// Update sum``                ``sum = sum - K;` `                ``// Traverse till current head``                ``while` `(prev != head) {``                    ``prev = prev.next;``                    ``aux += prev.val;``                    ``if` `(prev != head) {``                        ``umap.remove(aux);``                    ``}``                ``}` `                ``// Update the start value to``                ``// the next value of current head``                ``start.next = head.next;``            ``}` `            ``// If (sum - K) value not found``            ``else` `if` `(!umap.containsKey(sum)) {``                ``umap.put(sum, head);``            ``}` `            ``head = head.next;``        ``}` `        ``// Return the value of updated``        ``// head node``        ``return` `root.next;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// head Node``        ``ListNode head;` `        ``// Create Linked List``        ``head = getNode(``1``);``        ``head.next = getNode(``2``);``        ``head.next.next = getNode(-``3``);``        ``head.next.next.next = getNode(``3``);``        ``head.next.next.next.next = getNode(``1``);` `        ``// Given sum K``        ``int` `K = ``5``;` `        ``// Function call to get head node``        ``// of the updated Linked List``        ``head = removeZeroSum(head, K);` `        ``// Print the updated Linked List``        ``if` `(head != ``null``)``            ``printList(head);``    ``}``}` `// This code is contributed by jitin.`

## Python3

 `# Python3 program for the above approach` `# A Linked List Node``class` `ListNode:``    ``def` `__init__(``self``, val):``        ``self``.val ``=` `val``        ``self``.``next` `=` `None` `# Function to create Node``def` `getNode(data):``    ``temp ``=` `ListNode(data)``    ``temp.``next` `=` `None``    ``return` `temp` `# Function to print the Linked List``def` `printList(head):``    ``while` `(head.``next``):``        ``print``(head.val, end``=``' -> '``)``        ``head ``=` `head.``next``    ``print``(head.val, end``=``'')` `# Function that removes continuous nodes``# whose sum is K``def` `removeZeroSum(head, K):` `    ``# Root node initialise to 0``    ``root ``=` `ListNode(``0``)` `    ``# Append at the front of the given``    ``# Linked List``    ``root.``next` `=` `head` `    ``# Map to store the sum and reference``    ``# of the Node``    ``umap ``=` `dict``()` `    ``umap[``0``] ``=` `root` `    ``# To store the sum while traversing``    ``sum` `=` `0` `    ``# Traversing the Linked List``    ``while` `(head !``=` `None``):` `        ``# Find sum``        ``sum` `+``=` `head.val` `        ``# If found value with (sum - K)``        ``if` `((``sum` `-` `K) ``in` `umap):` `            ``prev ``=` `umap[``sum` `-` `K]``            ``start ``=` `prev` `            ``# Delete all the node``            ``# traverse till current node``            ``aux ``=` `sum` `            ``# Update sum``            ``sum` `=` `sum` `-` `K` `            ``# Traverse till current head``            ``while` `(prev !``=` `head):``                ``prev ``=` `prev.``next``                ``aux ``+``=` `prev.val``                ``if` `(prev !``=` `head):``                    ``umap.remove(aux)` `            ``# Update the start value to``            ``# the next value of current head``            ``start.``next` `=` `head.``next` `        ``# If (sum - K) value not found``        ``else``:``            ``umap[``sum``] ``=` `head` `        ``head ``=` `head.``next` `    ``# Return the value of updated``    ``# head node``    ``return` `root.``next`  `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `    ``# Create Linked List``    ``head ``=` `getNode(``1``)``    ``head.``next` `=` `getNode(``2``)``    ``head.``next``.``next` `=` `getNode(``-``3``)``    ``head.``next``.``next``.``next` `=` `getNode(``3``)``    ``head.``next``.``next``.``next``.``next` `=` `getNode(``1``)` `    ``# Given sum K``    ``K ``=` `5` `    ``# Function call to get head node``    ``# of the updated Linked List``    ``head ``=` `removeZeroSum(head, K)` `    ``# Print the updated Linked List``    ``if``(head !``=` `None``):``        ``printList(head)` `    ``# This code is contributed by pratham76`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;` `// A Linked List Node``class` `ListNode {``    ``public` `int` `val;``    ``public` `ListNode next;` `    ``// Constructor``    ``public` `ListNode(``int` `val)``    ``{``        ``this``.val = val;``        ``this``.next = ``null``;``    ``}``}` `class` `GFG {` `    ``// Function to create Node``    ``static` `ListNode getNode(``int` `data)``    ``{``        ``ListNode temp = ``new` `ListNode(data);``        ``return` `temp;``    ``}` `    ``// Function to print the Linked List``    ``static` `void` `printList(ListNode head)``    ``{``        ``while` `(head.next != ``null``) {``            ``Console.Write(head.val + ``" -> "``);``            ``head = head.next;``        ``}``        ``Console.Write(head.val);``    ``}` `    ``// Function that removes continuous nodes``    ``// whose sum is K``    ``static` `ListNode removeZeroSum(ListNode head, ``int` `K)``    ``{` `        ``// Root node initialise to 0``        ``ListNode root = ``new` `ListNode(0);` `        ``// Append at the front of the given``        ``// Linked List``        ``root.next = head;` `        ``// Map to store the sum and reference``        ``// of the Node``        ``Dictionary<``int``, ListNode> umap``            ``= ``new` `Dictionary<``int``, ListNode>();` `        ``umap.Add(0, root);` `        ``// To store the sum while traversing``        ``int` `sum = 0;` `        ``// Traversing the Linked List``        ``while` `(head != ``null``) {` `            ``// Find sum``            ``sum += head.val;` `            ``// If found value with (sum - K)``            ``if` `(umap.ContainsKey(sum - K)) {``                ``ListNode prev = umap[sum - K];``                ``ListNode start = prev;` `                ``// Delete all the node``                ``// traverse till current node``                ``int` `aux = sum;` `                ``// Update sum``                ``sum = sum - K;` `                ``// Traverse till current head``                ``while` `(prev != head) {``                    ``prev = prev.next;``                    ``aux += prev.val;` `                    ``if` `(prev != head) {``                        ``umap.Remove(aux);``                    ``}``                ``}` `                ``// Update the start value to``                ``// the next value of current head``                ``start.next = head.next;``            ``}` `            ``// If (sum - K) value not found``            ``else` `if` `(!umap.ContainsKey(sum)) {``                ``umap.Add(sum, head);``            ``}` `            ``head = head.next;``        ``}` `        ``// Return the value of updated``        ``// head node``        ``return` `root.next;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(``string``[] args)``    ``{` `        ``// head Node``        ``ListNode head;` `        ``// Create Linked List``        ``head = getNode(1);``        ``head.next = getNode(2);``        ``head.next.next = getNode(-3);``        ``head.next.next.next = getNode(3);``        ``head.next.next.next.next = getNode(1);` `        ``// Given sum K``        ``int` `K = 5;` `        ``// Function call to get head node``        ``// of the updated Linked List``        ``head = removeZeroSum(head, K);` `        ``// Print the updated Linked List``        ``if` `(head != ``null``)``            ``printList(head);``    ``}``}` `// This code is contributed by rutvik_56`

## Javascript

 ``

Output

`1 -> 2 -> -3 -> 3 -> 1`

Time Complexity: O(N), where N is the number of Node in the Linked List.
Auxiliary Space Complexity: O(N), where N is the number of Node in the Linked List.

My Personal Notes arrow_drop_up