Delete continuous nodes with sum K from a given linked list

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
Explanataion:
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
Explanataion:
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 0.
  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:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
  
#include <bits/stdc++.h>
using namespace std;
  
// A Linked List Node
struct ListNode {
    int val;
    ListNode* next;
  
    // Contructor
    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;
    }
    printf("%d", head->val);
}
  
// Function that removes continuos 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;
  
            // Delete all the node
            // traverse till current node
            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;
  
            // Update sum to zero
            sum = 0;
        }
  
        // 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
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
    printList(head);
    return 0;
}

chevron_right


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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




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.