# Hackerrank Compare two linked lists problem solution

In this HackerRank Compare two linked lists problem if we have given the pointer to the head of the node of two linked lists then we need to compare the data of both linked lists and check if they are equal or not. if all the data are the same then return 1 otherwise return 0.

## Problem solution in Python programming.

#!/bin/python3

import os
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)

if headA is None:
return 1 if headB is None else 0
if headB is None:
return 0
return 0
else:

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

tests = int(input())

for tests_itr in range(tests):
llist1_count = int(input())

for _ in range(llist1_count):
llist1_item = int(input())
llist1.insert_node(llist1_item)

llist2_count = int(input())

for _ in range(llist2_count):
llist2_item = int(input())
llist2.insert_node(llist2_item)

fptr.write(str(int(result)) + '\n')

fptr.close()

## Problem solution in Java Programming.

import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;
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);
}
}
}

}
return (head1 == null && head2 == null);
}

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 tests = scanner.nextInt();
scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

for (int testsItr = 0; testsItr < tests; testsItr++) {

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

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

llist1.insertNode(llist1Item);
}

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

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

llist2.insertNode(llist2Item);
}

bufferedWriter.write(String.valueOf(result ? 1 : 0));
bufferedWriter.newLine();
}

bufferedWriter.close();

scanner.close();
}
}

### Problem solution in 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);
}
}

int res=1;
while(head1 != NULL || head2 != NULL){
if(head1 == NULL) {res=0; break;}
if(head2 == NULL) {res=0; break;}
}
return res;

}

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

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

for (int tests_itr = 0; tests_itr < tests; tests_itr++) {

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

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

llist1->insert_node(llist1_item);
}

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

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

llist2->insert_node(llist2_item);
}

fout << result << "\n";
}

fout.close();

return 0;
}

### Problem solution in C programming.

#include <assert.h>
#include <limits.h>
#include <math.h>
#include <stdbool.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);
}
}

int res=1;
while(head1 != NULL || head2 != NULL){
if(head1 == NULL) {res=0; break;}
if(head2 == NULL) {res=0; break;}
}
return res;

}

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

char* tests_endptr;
char* tests_str = readline();
int tests = strtol(tests_str, &tests_endptr, 10);

if (tests_endptr == tests_str || *tests_endptr != '\0') { exit(EXIT_FAILURE); }

for (int tests_itr = 0; tests_itr < tests; tests_itr++) {
llist1->tail = NULL;

char* llist1_count_endptr;
char* llist1_count_str = readline();
int llist1_count = strtol(llist1_count_str, &llist1_count_endptr, 10);

if (llist1_count_endptr == llist1_count_str || *llist1_count_endptr != '\0') { exit(EXIT_FAILURE); }

for (int i = 0; i < llist1_count; i++) {
char* llist1_item_endptr;
char* llist1_item_str = readline();
int llist1_item = strtol(llist1_item_str, &llist1_item_endptr, 10);

if (llist1_item_endptr == llist1_item_str || *llist1_item_endptr != '\0') { exit(EXIT_FAILURE); }

}

llist2->tail = NULL;

char* llist2_count_endptr;
char* llist2_count_str = readline();
int llist2_count = strtol(llist2_count_str, &llist2_count_endptr, 10);

if (llist2_count_endptr == llist2_count_str || *llist2_count_endptr != '\0') { exit(EXIT_FAILURE); }

for (int i = 0; i < llist2_count; i++) {
char* llist2_item_endptr;
char* llist2_item_str = readline();
int llist2_item = strtol(llist2_item_str, &llist2_item_endptr, 10);

if (llist2_item_endptr == llist2_item_str || *llist2_item_endptr != '\0') { exit(EXIT_FAILURE); }

}

fprintf(fptr, "%d\n", result);
}

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

### Problem solution in 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);
}
}
}

let position =0,nodeA = headA , nodeB = headB
while(nodeA!=null&&nodeB!=null){
if(nodeA.data!=nodeB.data ){return 0}
nodeA = nodeA.next
nodeB = nodeB.next
}
if(nodeA!=null||nodeB!=null){
return 0
}
return 1
}

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

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

for (let testsItr = 0; testsItr < tests; testsItr++) {
const llist1Count = parseInt(readLine(), 10);

let llist1 = new SinglyLinkedList();

for (let i = 0; i < llist1Count; i++) {
const llist1Item = parseInt(readLine(), 10);
llist1.insertNode(llist1Item);
}

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

let llist2 = new SinglyLinkedList();

for (let i = 0; i < llist2Count; i++) {
const llist2Item = parseInt(readLine(), 10);
llist2.insertNode(llist2Item);
}