## Algorithm

Problem Name: Data Structures - Compare two linked lists

In this HackerRank in Data Structures - Compare two linked lists solution

You’re given the pointer to the head nodes of two linked lists. Compare the data in the nodes of the linked lists to check if they are equal. If all data attributes are equal and the lists are the same length, return 1. Otherwise, return 0.

Example

list1 = 1 -> 2 -> 3 -> NULL

list2 = 1 -> 2 -> 3 -> 4 -> NULL

The two lists have equal data attributes for the first 3 nodes. list2 is longer, though, so the lists are not equal. Return 0.

Function Description

Complete the compare_lists function in the editor below.

compare_lists has the following parameters:

Returns

• int: return 1 if the lists are equal, or 0 otherwise

Input Format

The first line contains an integer t, the number of test cases. Each of the test cases has the following format:
The first line contains an integer n, the number of nodes in the first linked list.
Each of the next n lines contains an integer, each a value for a data attribute.
The next line contains an integer m, the number of nodes in the second linked list.
Each of the next m lines contains an integer, each a value for a data attribute.

Constraints

• 1 <= t <= 10
• 1 <= n,m <= 1000
• 1 <= list1[i],list2[i] <= 1000

Output Format

Compare the two linked lists and `return` 1 if the lists are equal. Otherwise, `return` 0. Do NOT print anything to stdout/console.

The output is handled by the code in the editor and it is as follows:

For each test case, in a new line, print 1 if the two lists are equal, else print 0.

Sample Input

``````2
2
1
2
1
1
2
1
2
2
1
2
``````

Sample Output

``````0
1
``````

Explanation

There are t = 2 test cases, each with a pair of linked lists.
• In the first case, linked lists are: 1 -> 2 -> NULL and 1 -> NULL

• In the second case, linked lists are: 1 -> 2 -> NULL and 1 -> 2 -> 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 <stdio.h>
#include <stdlib.h>
#include <string.h>

int data;
};

};

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

return node;
}

} else {
}

}

while (node) {
fprintf(fptr, "%d", node->data);

node = node->next;

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

while (node) {
node = node->next;

free(temp);
}
}

// Complete the compare_lists function below.

/*
*
*     int data;
* };
*
*/
int res=1;
}
return res;

}

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

char* tests_endptr;
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;
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;
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;
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;
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;
}
``````
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;
}
};

while (node) {
fout << node->data;

node = node->next;

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

while (node) {
node = node->next;

free(temp);
}
}

int res=1;
}
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;
}
``````
Copy The Code &

### #3 Code Example with Java Programming

```Code - Java Programming```

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

public class Solution {

public int data;

this.data = nodeData;
this.next = null;
}
}

this.tail = null;
}

public void insertNode(int nodeData) {

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

}
}

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();
}
}
``````
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++];
}

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

constructor() {
this.tail = null;
}

insertNode(nodeData) {

} else {
this.tail.next = node;
}

this.tail = node;
}
};

while (node != null) {
ws.write(String(node.data));

node = node.next;

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

// Complete the CompareLists function below.

/*
*
*     int data;
* }
*
*/
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);

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

for (let i = 0; i  <  llist1Count; i++) {
llist1.insertNode(llist1Item);
}

for (let i = 0; i  <  llist2Count; i++) {
llist2.insertNode(llist2Item);
}

ws.write((result ? 1 : 0) + "\n");
}

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

### #5 Code Example with Python Programming

```Code - 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

while node:
fptr.write(str(node.data))

node = node.next

if node:
fptr.write(sep)

# Complete the compare_lists function below.

#
#
#     int data
#
#
return 1 if headB is None else 0
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)