## Algorithm

Problem Name: Data Structures - Delete duplicate-value nodes from a sorted linked list

In this HackerRank in Data Structures - Delete duplicate-value nodes from a sorted linked list solutions

You are given the pointer to the head node of a sorted linked list, where the data in the nodes is in ascending order. Delete nodes and return a sorted list with each distinct value in the original list. The given head pointer may be null indicating that the list is empty.

Example

head refers to the first node in the list.

1 -> 2 -> 2 -> 3 -> 3 -> 3 -> 3 ->NULL

Remove 1 of the 2 data values and return head pointing to the revised list 1 -> 2 -> 3 -> NULL

Function Description

Complete the removeDuplicates function in the editor below.

removeDuplicates has the following parameter:

• SinglyLinkedListNode pointer head: a reference to the head of the list

Returns

• SinglyLinkedListNode pointer: a reference to the head of the revised list

Input Format

The first line contains an integer t, the number of test cases.

The format for each test case is as follows:

The first line contains an integer n, the number of elements in the linked list.
Each of the next n lines contains an integer, the data value for each of the elements of the linked list.

Constraints

• 1 <= t <= 10
• 1 <= n <= 1000
• 1 <= list[i] <= 1000

Sample Input

``````STDIN   Function
-----   --------
1       t = 1
5       n = 5
1       data values = 1, 2, 2, 3, 4
2
2
3
4
``````

Sample Output

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

Explanation

The initial linked list is: 1 -> 2 -> 2 -> 3 -> 4 -> NULL

The final linked list is: 1 -> 2 -> 3 -> 4 -> NULL

## Code Examples

### #1 Code Example with C Programming

```Code - C Programming```

``````
#include <assert.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int data;
};

};

node->data = node_data;
node->next = NULL;

return node;
}

} else {
}

}

void print_singly_linked_list(SinglyLinkedListNode* node, char* sep, FILE* fptr) {
while (node) {
fprintf(fptr, "%d", node->data);

node = node->next;

if (node) {
fprintf(fptr, "%s", sep);
}
}
}

while (node) {
SinglyLinkedListNode* temp = node;
node = node->next;

free(temp);
}
}

/*
* Complete the 'removeDuplicates' function below.
*
* The function is expected to return an INTEGER_SINGLY_LINKED_LIST.
* The function accepts INTEGER_SINGLY_LINKED_LIST llist as parameter.
*/

/*
* For your reference:
*
*     int data;
* };
*
*/

SinglyLinkedListNode* nextBoi = currBoi->next;

while(nextBoi != NULL){
if(currBoi->data == nextBoi->data){
SinglyLinkedListNode* temp = nextBoi;
nextBoi = nextBoi->next;
currBoi->next = nextBoi;
temp->next = NULL;
free(temp);
} else {
currBoi = currBoi->next;
nextBoi = nextBoi->next;
}
}
}

int main()
{
FILE* fptr = fopen(getenv("OUTPUT_PATH"), "w");

char* t_endptr;
char* t_str = readline();
int t = strtol(t_str, &t_endptr, 10);

if (t_endptr == t_str || *t_endptr != '\0') { exit(EXIT_FAILURE); }

for (int t_itr = 0; t_itr < t; t_itr++) {
llist->tail = NULL;

char* llist_count_endptr;
char* llist_count_str = readline();
int llist_count = strtol(llist_count_str, &llist_count_endptr, 10);

if (llist_count_endptr == llist_count_str || *llist_count_endptr != '\0') { exit(EXIT_FAILURE); }

for (int i = 0; i  <  llist_count; i++) {
char* llist_item_endptr;
char* llist_item_str = readline();
int llist_item = strtol(llist_item_str, &llist_item_endptr, 10);

if (llist_item_endptr == llist_item_str || *llist_item_endptr != '\0') { exit(EXIT_FAILURE); }

}

char *sep = " ";

fprintf(fptr, "\n");

}

fclose(fptr);

return 0;
}

size_t alloc_length = 1024;
size_t data_length = 0;
char* data = malloc(alloc_length);

while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);

if (!line) { break; }

data_length += strlen(cursor);

if (data_length  <  alloc_length - 1 || data[data_length - 1] == '\n') { break; }

size_t new_length = alloc_length << 1;
data = realloc(data, new_length);

if (!data) { break; }

alloc_length = new_length;
}

if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';
}

data = realloc(data, data_length);

return data;
}
``````
Copy The Code &

### #2 Code Example with C++ Programming

```Code - C++ Programming```

``````
#include <bits/stdc++.h>

using namespace std;

public:
int data;

this->data = node_data;
this->next = nullptr;
}
};

public:

this->tail = nullptr;
}

void insert_node(int node_data) {

} else {
this->tail->next = node;
}

this->tail = node;
}
};

void print_singly_linked_list(SinglyLinkedListNode* node, string sep, ofstream& fout) {
while (node) {
fout << node->data;

node = node->next;

if (node) {
fout << sep;
}
}
}

while (node) {
SinglyLinkedListNode* temp = node;
node = node->next;

free(temp);
}
}

SinglyLinkedListNode *curr = llist;
while (curr != NULL) {
SinglyLinkedListNode *next = curr->next;
while (next != NULL && next->data == curr->data)
next = next->next;
curr->next = next;
curr = next;
if (next != NULL) next = next->next;
}
return llist;
}

int main()
{
ofstream fout(getenv("OUTPUT_PATH"));

int t;
cin >> t;
cin.ignore(numeric_limits < streamsize>::max(), '\n');

for (int t_itr = 0; t_itr  <  t; t_itr++) {

int llist_count;
cin >> llist_count;
cin.ignore(numeric_limits < streamsize>::max(), '\n');

for (int i = 0; i  <  llist_count; i++) {
int llist_item;
cin >> llist_item;
cin.ignore(numeric_limits < streamsize>::max(), '\n');

llist->insert_node(llist_item);
}

print_singly_linked_list(llist1, " ", fout);
fout << "\n";

}

fout.close();

return 0;
}
``````
Copy The Code &

### #3 Code Example with Java Programming

```Code - Java Programming```

``````
import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;

public class Solution {

static class SinglyLinkedListNode {
public int data;

public SinglyLinkedListNode(int nodeData) {
this.data = nodeData;
this.next = null;
}
}

static class SinglyLinkedList {

this.tail = null;
}

public void insertNode(int nodeData) {

if (this.head == null) {
} else {
this.tail.next = node;
}

this.tail = node;
}
}

public static void printSinglyLinkedList(SinglyLinkedListNode node, String sep, BufferedWriter bufferedWriter) throws IOException {
while (node != null) {
bufferedWriter.write(String.valueOf(node.data));

node = node.next;

if (node != null) {
bufferedWriter.write(sep);
}
}
}

// Write your code here
SinglyLinkedListNode temp = llist;

while(temp.next!=null)
{
if(temp.data == temp.next.data)
{

temp.next = temp.next.next;
}
else
{
temp = temp.next;
}
}
return llist;
}
class Result {

}

private static final Scanner scanner = new Scanner(System.in);

public static void main(String[] args) throws IOException {
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

int t = scanner.nextInt();
scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

for (int tItr = 0; tItr < t; tItr++) {

int llistCount = scanner.nextInt();
scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

for (int i = 0; i  <  llistCount; i++) {
int llistItem = scanner.nextInt();
scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

llist.insertNode(llistItem);
}

printSinglyLinkedList(llist1, " ", bufferedWriter);
bufferedWriter.newLine();
}

bufferedWriter.close();

scanner.close(>;
}
}
``````
Copy The Code &

### #4 Code Example with Javascript Programming

```Code - Javascript Programming```

``````
'use strict';

const fs = require('fs');

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
inputString += inputStdin;
});

process.stdin.on('end', _ => {
inputString = inputString.replace(/\s*\$/, '')
.split('\n')
.map(str => str.replace(/\s*\$/, ''));

main();
});

return inputString[currentLine++];
}

const SinglyLinkedListNode = class {
constructor(nodeData) {
this.data = nodeData;
this.next = null;
}
};

const SinglyLinkedList = class {
constructor() {
this.tail = null;
}

insertNode(nodeData) {
const node = new SinglyLinkedListNode(nodeData);

if (this.head == null) {
} else {
this.tail.next = node;
}

this.tail = node;
}
};

function printSinglyLinkedList(node, sep, ws) {
while (node != null) {
ws.write(String(node.data));

node = node.next;

if (node != null) {
ws.write(sep);
}
}
}

/*
* Complete the 'removeDuplicates' function below.
*
* The function is expected to return an INTEGER_SINGLY_LINKED_LIST.
* The function accepts INTEGER_SINGLY_LINKED_LIST llist as parameter.
*/

/*
* For your reference:
*
*     int data;
* }
*
*/

var node = head;
while (node) {
if (node.next && node.data === node.next.data) {
node.next = node.next.next;
} else {
node = node.next;
}
}
}

function main() {
const ws = fs.createWriteStream(process.env.OUTPUT_PATH);

const t = parseInt(readLine(), 10);

for (let tItr = 0; tItr  <  t; tItr++) {
const llistCount = parseInt(readLine(), 10);

let llist = new SinglyLinkedList();

for (let i = 0; i  <  llistCount; i++) {
const llistItem = parseInt(readLine(), 10);
llist.insertNode(llistItem);
}

let llist1 = removeDuplicates(llist.head);

printSinglyLinkedList(llist1, " ", ws)
ws.write("\n");
}

ws.end();
}
``````
Copy The Code &

### #5 Code Example with Python Programming

```Code - Python Programming```

``````
#!/bin/python3

import math
import os
import random
import re
import sys

def __init__(self, node_data):
self.data = node_data
self.next = None

def __init__(self):
self.tail = None

def insert_node(self, node_data):

else:
self.tail.next = node

self.tail = node

def print_singly_linked_list(node, sep, fptr):
while node:
fptr.write(str(node.data))

node = node.next

if node:
fptr.write(sep)

#
# Complete the 'removeDuplicates' function below.
#
# The function is expected to return an INTEGER_SINGLY_LINKED_LIST.
# The function accepts INTEGER_SINGLY_LINKED_LIST llist as parameter.
#

#
# For your reference:
#
#     int data
#
#

ans=None
s=set()
if head.data not in s:
else:

if __name__ == '__main__':
fptr = open(os.environ['OUTPUT_PATH'], 'w')

t = int(input())

for t_itr in range(t):
llist_count = int(input())

for _ in range(llist_count):
llist_item = int(input())
llist.insert_node(llist_item)