Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Sum of all distinct nodes in a linked list

  • Difficulty Level : Easy
  • Last Updated : 04 Jun, 2021

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:
2 and 4 are the only non-duplicate nodes and 2 + 4 = 6.
Input: 1 -> 3 -> 1 -> 3 -> 1 -> 3 -> NULL 
Output:
 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

 

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++




// C++ implementation 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;
}

Java




// Java implementation 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

Python3




# 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

C#




// 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

Javascript




<script>
 
// Javascript implementation of the approach
 
// Represents a node of linked list
class Node {
        constructor(val) {
            this.data = val;
            this.next = null;
         }
     }
 
// Function to insert node in a linked list
function insert( head,  item)
{
    let ptr = head;
    var 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
function sumOfNonDupNode( head)
{
    var ptr1 = head;
    var ptr2;
    var sum = 0;
 
    while (ptr1 != null) {
        ptr2 = head;
        var 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
 
    let 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);
 
    document.write(sumOfNonDupNode(head));
 
// This code is contributed by Jana_sayantan.
</script>
Output: 
6

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!