链表中的绝对非重复计数

给定一个由整数组成的链表，任务是打印链表中存在的不同绝对值的数量。

例子：

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}. 
 

方法：为了解决这个问题，我们需要一个 Set 或一个 HashSet 来存储链表中存在的不同绝对值。遍历整个链表和插入设置每个节点的绝对值后，集合的大小使存在于链表绝对不同值的数量。

下面是该方法的实现：

C++

// C++ Program to print the count
// of distinct absolute values
// in a linked list
 
#include 
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 = (Node*)malloc(
        sizeof(struct 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 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 s = new HashSet();
        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#

// 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 s = new HashSet();
    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

输出：

6

时间复杂度： O(N)
辅助空间： O(N)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。