Absolute distinct count in a Linked List

Last Updated : 16 Jan, 2023

Given a Linked List consisting of integers, the task is to print the number of distinct absolute values present in the Linked List.

Examples:

Input: -1 -> -2 -> 0 -> 4 -> 5 -> 8
Output: 6
Explanation:
Distinct absolute node values are {0, 1, 2, 4, 5, 8}

Input: -1 -> -1 -> -1 -> 0 -> 1
Output: 2
Explanation:
Distinct absolute node values are {0, 1}.

Approach: In order to solve this problem, we require a Set or a HashSet to store the distinct absolute values present in the Linked List. After traversing the entire linked list and inserting absolute values of every node in the Set, the size of the Set gives the number of absolute distinct values present in the Linked List.

Below is the implementation of the approach:

C++

// C++ Program to print the count
// of distinct absolute values
// in a linked list

#include <bits/stdc++.h>
using namespace std;
// Node of a singly
// linked list
struct Node {
    int data;
    Node* next;
};

// Function to insert a
// node at the beginning
// of a singly Linked List
void push(Node** head_ref, int new_data)
{
    // Allocate node
    Node* new_node = new Node();

    // Insert the data
    new_node->data = new_data;

    // Point to the current head
    new_node->next = (*head_ref);

    // Make the current Node
    // the new head
    (*head_ref) = new_node;
}

// Function to return number of
// distinct absolute values
// present in the linked list
int distinctCount(Node* head_1)
{
    Node* ptr = head_1;
    unordered_set<int> s;

    while (ptr != NULL) {
        s.insert(abs(ptr->data));
        ptr = ptr->next;
    }

    return s.size();
}
int main()
{
    // Create the head
    Node* head1 = NULL;
    // Insert Nodes
    push(&head1, -1);
    push(&head1, -2);
    push(&head1, 0);
    push(&head1, 4);
    push(&head1, 5);
    push(&head1, 8);

    int k = distinctCount(head1);
    cout << k;
    return 0;
}

Java

// Java program to calculate
// the count of distinct
// absolute values in a
// linked list

import java.util.*;

class GFG {

    // Node of the singly
    // linked list
    static class Node {
        int data;
        Node next;
    };

    // Function to insert a node
    // at the beginning of the
    // singly Linked List
    static Node push(Node head_ref,
                     int new_data)
    {
        // Allocate node
        Node new_node = new Node();

        // Insert the data
        new_node.data = new_data;

        // Point the current Node
        // to the current head
        new_node.next = (head_ref);

        // Make the current node
        // as the new head
        (head_ref) = new_node;

        return head_ref;
    }

    // Function to return the count of
    // distinct absolute values
    // present in the Linked list
    static int distinctCount(Node head_ref1)
    {
        Set<Integer> s = new HashSet<Integer>();
        Node ptr1 = head_ref1;

        while (ptr1 != null) {
            s.add(Math.abs(ptr1.data));
            ptr1 = ptr1.next;
        }
        return s.size();
    }

    // Driver Code
    public static void main(String args[])
    {
        // Create the head
        Node head1 = null;
        // Insert nodes to the
        // Linked List
        head1 = push(head1, -1);
        head1 = push(head1, -2);
        head1 = push(head1, 0);
        head1 = push(head1, 4);
        head1 = push(head1, 5);
        head1 = push(head1, 8);

        int ans = distinctCount(head1);
        System.out.println(ans);
    }
}

Python3

# Python3 program to calculate
# the count of distinct 
# absolute values in a 
# linked list
 
class Node:  
         
    def __init__(self, data):  
        self.data = data  
        self.next = next
             
# Function to insert a 
# node at the beginning  
# of the singly Linked List  
def push( head_ref, new_data) : 
     
    # Allocate node  
    new_node = Node(0)  
     
    # Insert data  
    new_node.data = new_data  
     
    # Point to the head 
    new_node.next = (head_ref)  
     
    # Make the new Node
    # the new head
    (head_ref) = new_node 
     
    return head_ref
    
# Function to return the 
# count of distinct absolute
# values in the linked list
def distinctCount(head_ref1): 
    s = set() 
    ptr1 = head_ref1
    # set keeps all unique elements 
    while (ptr1 != None): 
        s.add(abs(ptr1.data)) 
        ptr1 = ptr1.next
    return len(s)    
    
# Driver code  
# Create the Head
head1 = None
# Insert nodes  
head1 = push(head1, -1)  
head1 = push(head1, -2)  
head1 = push(head1, 0)  
head1 = push(head1, 4)  
head1 = push(head1, 5)
head1 = push(head1, 8)

ans = distinctCount(head1)
print(ans)

// C# program to calculate the count
// of distinct absolute values in a
// linked list
using System;
using System.Collections.Generic;

class GFG{

// Node of the singly
// linked list
class Node 
{
    public int data;
    public Node next;
};

// Function to insert a node
// at the beginning of the
// singly Linked List
static Node push(Node head_ref,
                 int new_data)
{
    
    // Allocate node
    Node new_node = new Node();

    // Insert the data
    new_node.data = new_data;

    // Point the current Node
    // to the current head
    new_node.next = (head_ref);

    // Make the current node
    // as the new head
    (head_ref) = new_node;

    return head_ref;
}

// Function to return the count of
// distinct absolute values
// present in the Linked list
static int distinctCount(Node head_ref1)
{
    HashSet<int> s = new HashSet<int>();
    Node ptr1 = head_ref1;

    while (ptr1 != null)
    {
        s.Add(Math.Abs(ptr1.data));
        ptr1 = ptr1.next;
    }
    return s.Count;
}

// Driver Code
public static void Main(String []args)
{
    
    // Create the head
    Node head1 = null;
    
    // Insert nodes to the
    // Linked List
    head1 = push(head1, -1);
    head1 = push(head1, -2);
    head1 = push(head1, 0);
    head1 = push(head1, 4);
    head1 = push(head1, 5);
    head1 = push(head1, 8);

    int ans = distinctCount(head1);
    Console.WriteLine(ans);
}
}

// This code is contributed by Princi Singh

JavaScript

    // JavaScript program to calculate
    // the count of distinct absolute 
    // values in a linked list
    
    class Node {
        constructor(data) {
            this.data = data;
            this.next = null;
        }
    }

    class LinkedList {
        constructor() {
            this.head = null;
        }

        // Function to insert a node at the beginning of the linked list
        push(newData) {
            const newNode = new Node(newData);
            newNode.next = this.head;
            this.head = newNode;
        }

        // Function to return the count of distinct absolute values present in the linked list
        distinctCount() {
            const set = new Set();
            let current = this.head;
            while (current) {
                set.add(Math.abs(current.data));
                current = current.next;
            }
            return set.size;
        }
    }

    const ll = new LinkedList();
    ll.push(-1);
    ll.push(-2);
    ll.push(0);
    ll.push(4);
    ll.push(5);
    ll.push(8);

    console.log(ll.distinctCount());
    
    // This code is contributed by lokesh.

Output:

Time Complexity: O(N), as we are using a loop to traverse N times.

Auxiliary Space: O(N), as we are using extra space for set s.

Absolute distinct count in a Linked List

ShivaTeja2

Improve

Article Tags :

Practice Tags :

Absolute distinct count in a Linked List

Similar Reads

Thank You!

What kind of Experience do you want to share?