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

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:
{

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

}
{
Node* p=new Node(data);

}

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

}

}
{
while(start)
{
cout<<start->data<<" ";
start=start->next;
}
}
};

int main()
{
Solution mylist;
int T,data;
cin>>T;
while(T-->0){
cin>>data;
}

}```

### 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) {
return null;
}
while(s.next!=null){
if(s.data==s.next.data){
s.next=s.next.next;
}
else{
s=s.next;
}
}

}

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

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

}
}```

### Python

```class Node:
def __init__(self,data):
self.data = data
self.next = None
class Solution:
p = Node(data)
else:
while(start.next!=None):
start=start.next
start.next=p
while current:
print(current.data,end=' ')
current = current.next
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