# Day 24: More Linked List | 30 Days Of Code | HackerRank Solution

Hello coders, today we are going to solve Day 24: More Linked List HackerRank Solution in C++, Java and Python.

Contents

## Task

Node class is provided for you in the editor. A Node object has an integer data field, data, and a Node instance pointer, next, pointing to another node (i.e.: the next node in a list).

removeDuplicates function is declared in your editor, which takes a pointer to the head node of a linked list as a parameter. Complete removeDuplicates so that it deletes any duplicate nodes from the list and returns the head of the updated list.

Note: The head pointer may be null, indicating that the list is empty. Be sure to reset your next pointer when performing deletions to avoid breaking the list.

## Input Format

You do not need to read any input from stdin. The following input is handled by the locked stub code and passed to the removeDuplicates function:
The first line contains an integer, N, the number of nodes to be inserted.
The N subsequent lines each contain an integer describing the data value of a node being inserted at the list’s tail.

## Constraints

• The data elements of the linked list argument will always be in non-decreasing order.

## Output Format

Your removeDuplicates function should return the head of the updated linked list. The locked stub code in your editor will print the returned list to stdout.

Sample Input

``````6
1
2
2
3
3
4``````

Sample Output

``1 2 3 4 ``

Explanation

N = 6, and our non-decreasing list is {1, 2, 2, 3, 3, 4}. The values 2 and 3 both occur twice in the list, so we remove the two duplicate nodes. We then return our updated (ascending) list, which is {1, 2, 3, 4}.

## Solution – Day 24: More Linked List

### C++

```#include <cstddef>
#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
class Node
{
public:
int data;
Node *next;
Node(int d){
data=d;
next=NULL;
}
};
class Solution{
public:
Node* removeDuplicates(Node *head)
{
if (!head)
return head;

Node *node = head;
while (node->next) {
if (node->data == node->next->data)
node->next = node->next->next;
else
node = node->next;
}

return head;
}
Node* insert(Node *head,int data)
{
Node* p=new Node(data);
if(head==NULL){
head=p;

}
else if(head->next==NULL){
head->next=p;

}
else{
Node *start=head;
while(start->next!=NULL){
start=start->next;
}
start->next=p;

}
return head;

}
void display(Node *head)
{
Node *start=head;
while(start)
{
cout<<start->data<<" ";
start=start->next;
}
}
};

int main()
{
Node* head=NULL;
Solution mylist;
int T,data;
cin>>T;
while(T-->0){
cin>>data;
head=mylist.insert(head,data);
}
head=mylist.removeDuplicates(head);

mylist.display(head);

}```

### Java

```import java.io.*;
import java.util.*;
class Node{
int data;
Node next;
Node(int d){
data=d;
next=null;
}

}
class Solution
{

public static Node removeDuplicates(Node head) {
if(head==null){
return null;
}
Node s=head;
while(s.next!=null){
if(s.data==s.next.data){
s.next=s.next.next;
}
else{
s=s.next;
}
}
return head;

}

public static  Node insert(Node head,int data)
{
Node p=new Node(data);
if(head==null)
head=p;
else if(head.next==null)
head.next=p;
else
{
Node start=head;
while(start.next!=null)
start=start.next;
start.next=p;

}
return head;
}
public static void display(Node head)
{
Node start=head;
while(start!=null)
{
System.out.print(start.data+" ");
start=start.next;
}
}
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
Node head=null;
int T=sc.nextInt();
while(T-->0){
int ele=sc.nextInt();
head=insert(head,ele);
}
head=removeDuplicates(head);
display(head);

}
}```

### Python

```class Node:
def __init__(self,data):
self.data = data
self.next = None
class Solution:
def insert(self,head,data):
p = Node(data)
if head==None:
head=p
elif head.next==None:
head.next=p
else:
start=head
while(start.next!=None):
start=start.next
start.next=p
return head
def display(self,head):
current = head
while current:
print(current.data,end=' ')
current = current.next
def removeDuplicates(self, head):
curr = head
while curr is not None and curr.next is not None:
while curr.next is not None and curr.data is curr.next.data:
curr.next = curr.next.next
curr = curr.next
return head
mylist= Solution()
T=int(input())
head=None
for i in range(T):
data=int(input())
head=mylist.insert(head,data)
head=mylist.removeDuplicates(head)
mylist.display(head); ```

Disclaimer: The above Problem (Day 24: More Linked List) is generated by Hacker Rank but the Solution is Provided by CodingBroz. This tutorial is only for Educational and Learning Purpose.