Sum of all distinct nodes in a linked list

Given a linked list and it may consist of duplicate nodes. The task is to find the sum of non-duplicate nodes.

Examples:

Input: 1 -> 2 -> 1 -> 3 -> 4 -> 3 -> NULL
Output: 6
2 and 4 are the only non-duplicate nodes and 2 + 4 = 6.



Input: 1 -> 3 -> 1 -> 3 -> 1 -> 3 -> NULL
Output: 0

Approach: We traverse the whole linked list and for each node we check throughout the linked list whether the node has duplicate or not. If there is no duplicate node then we add that node to the variable which stores the sum.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementaion of the approach
#include <iostream>
using namespace std;
  
// Represents a node of linked list
struct Node {
    int data;
    Node* next;
};
  
// Function to insert node in a linked list
void insert(Node** head, int item)
{
    Node* ptr = *head;
    Node* temp = new Node;
  
    temp->data = item;
    temp->next = NULL;
  
    if (*head == NULL)
        *head = temp;
    else {
        while (ptr->next != NULL)
            ptr = ptr->next;
        ptr->next = temp;
    }
}
  
// Function to find the sum of non duplicate nodes
int sumOfNonDupNode(Node* head)
{
    Node* ptr1 = head;
    Node* ptr2;
    int sum = 0, flag = 0;
  
    while (ptr1 != NULL) {
        ptr2 = head;
        bool flag = false;
  
        // Check if current node has some duplicate
        while (ptr2 != NULL) {
  
            // Check for duplicate node
            if (ptr1 != ptr2 && ptr1->data == ptr2->data) {
                flag = true;
                break;
            }
  
            // Get to the next node
            ptr2 = ptr2->next;
        }
  
        // If current node is unique
        if (!flag)
            sum += ptr1->data;
  
        // Get to the next node
        ptr1 = ptr1->next;
    }
    return sum;
}
  
// Driver code
int main()
{
    Node* head = NULL;
  
    insert(&head, 1);
    insert(&head, 2);
    insert(&head, 1);
    insert(&head, 3);
    insert(&head, 4);
    insert(&head, 3);
  
    cout << sumOfNonDupNode(head) << endl;
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementaion of the approach
class GFG {
  
    // Represents a node of linked list
    static class Node {
        int data;
        Node next;
    }
  
    // Function to insert node in a linked list
    static Node insert(Node head, int item)
    {
        Node ptr = head;
        Node temp = new Node();
  
        temp.data = item;
        temp.next = null;
  
        if (head == null)
            head = temp;
        else {
            while (ptr.next != null)
                ptr = ptr.next;
            ptr.next = temp;
        }
        return head;
    }
  
    // Function to find the sum of non duplicate nodes
    static int sumOfNonDupNode(Node head)
    {
        Node ptr1 = head;
        Node ptr2;
        int sum = 0;
  
        while (ptr1 != null) {
            ptr2 = head;
            boolean flag = false;
  
            // Check if current node has some duplicate
            while (ptr2 != null) {
  
                // Check for duplicate node
                if (ptr1 != ptr2 && ptr1.data == ptr2.data) {
                    flag = true;
                    break;
                }
  
                // Get to the next node
                ptr2 = ptr2.next;
            }
  
            // If current node is unique
            if (!flag)
                sum += ptr1.data;
  
            // Get to the next node
            ptr1 = ptr1.next;
        }
        return sum;
    }
  
    // Driver code
    public static void main(String args[])
    {
        Node head = null;
  
        head = insert(head, 1);
        head = insert(head, 2);
        head = insert(head, 1);
        head = insert(head, 3);
        head = insert(head, 4);
        head = insert(head, 3);
  
        System.out.print(sumOfNonDupNode(head));
    }
}
  
// This code is contributed by Arnab Kundu

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach
  
# Represents node of the linked list
class Node:
      
    def __init__(self, data):
        self.data = data
        self.next = None
  
# Insertion in linked list
def insert(head, item):
  
    ptr = head
    temp = Node(item)
      
    if head == None:
        head = temp
    else:
        while ptr.next != None:
            ptr = ptr.next
  
        ptr.next = temp
          
    return head
  
# Function to find the sum of 
# non duplicate nodes
def sumOfNonDupNode(head):
  
    ptr1 = head
    Sum = flag = 0
  
    while ptr1 != None:
        ptr2, flag = head, False
  
        # Check if current node 
        # has some duplicate
        while ptr2 != None:
  
            # Check for duplicate node
            if (ptr1 != ptr2 and 
                ptr1.data == ptr2.data): 
                flag = True
                break
  
            # Get to the next node
            ptr2 = ptr2.next
          
        # If current node is unique
        if not flag:
            Sum += ptr1.data
  
        # Get to the next node
        ptr1 = ptr1.next
      
    return Sum
  
# Driver code
if __name__ == "__main__":
  
    head = None
  
    head = insert(head, 1)
    head = insert(head, 2)
    head = insert(head, 1)
    head = insert(head, 3)
    head = insert(head, 4)
    head = insert(head, 3)
  
    print(sumOfNonDupNode(head))
      
# This code is contributed by Rituraj Jain

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
using System;
  
class GFG {
  
    public class Node {
        public int data;
        public Node next;
    }
  
    // Function to insert node in a linked list
    static Node insert(Node head, int item)
    {
        Node ptr = head;
        Node temp = new Node();
  
        temp.data = item;
        temp.next = null;
  
        if (head == null)
            head = temp;
        else {
            while (ptr.next != null)
                ptr = ptr.next;
            ptr.next = temp;
        }
        return head;
    }
  
    // Function to find the sum of non duplicate nodes
    static int sumOfNonDupNode(Node head)
    {
        Node ptr1 = head;
        Node ptr2;
        int sum = 0;
  
        while (ptr1 != null) {
            ptr2 = head;
            bool flag = false;
  
            // Check if current node has some duplicate
            while (ptr2 != null) {
  
                // Check for duplicate node
                if (ptr1 != ptr2 && ptr1.data == ptr2.data) {
                    flag = true;
                    break;
                }
  
                // Get to the next node
                ptr2 = ptr2.next;
            }
  
            // If current node is unique
            if (!flag)
                sum += ptr1.data;
  
            // Get to the next node
            ptr1 = ptr1.next;
        }
        return sum;
    }
  
    // Driver code
    public static void Main(String[] args)
    {
        Node head = null;
  
        head = insert(head, 1);
        head = insert(head, 2);
        head = insert(head, 1);
        head = insert(head, 3);
        head = insert(head, 4);
        head = insert(head, 3);
  
        Console.Write(sumOfNonDupNode(head));
    }
}
  
// This code contributed by Rajput-Ji

chevron_right


Output:

6


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.





Article Tags :
Practice Tags :


2


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.