Algorithm
Problem Name: Data Structures -
In this HackerRank in Data Structures -
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:
- SinglyLinkedListNode llist1: a reference to the head of a list
- SinglyLinkedListNode llist2: a reference to the head of a list
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
-
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>
char* readline();
typedef struct SinglyLinkedListNode SinglyLinkedListNode;
typedef struct SinglyLinkedList SinglyLinkedList;
struct SinglyLinkedListNode {
int data;
SinglyLinkedListNode* next;
};
struct SinglyLinkedList {
SinglyLinkedListNode* head;
SinglyLinkedListNode* tail;
};
SinglyLinkedListNode* create_singly_linked_list_node(int node_data) {
SinglyLinkedListNode* node = malloc(sizeof(SinglyLinkedListNode));
node->data = node_data;
node->next = NULL;
return node;
}
void insert_node_into_singly_linked_list(SinglyLinkedList** singly_linked_list, int node_data) {
SinglyLinkedListNode* node = create_singly_linked_list_node(node_data);
if (!(*singly_linked_list)->head) {
(*singly_linked_list)->head = node;
} else {
(*singly_linked_list)->tail->next = node;
}
(*singly_linked_list)->tail = node;
}
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);
}
}
}
void free_singly_linked_list(SinglyLinkedListNode* node) {
while (node) {
SinglyLinkedListNode* temp = node;
node = node->next;
free(temp);
}
}
// Complete the compare_lists function below.
/*
* For your reference:
*
* SinglyLinkedListNode {
* int data;
* SinglyLinkedListNode* next;
* };
*
*/
bool compare_lists(SinglyLinkedListNode* head1, SinglyLinkedListNode* head2) {
int res=1;
while(head1 != NULL || head2 != NULL){
if(head1 == NULL) {res=0; break;}
if(head2 == NULL) {res=0; break;}
if(head1->data != head2->data){res=0;break;}
head1=head1->next;
head2=head2->next;
}
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++) {
SinglyLinkedList* llist1 = malloc(sizeof(SinglyLinkedList)>;
llist1->head = NULL;
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); }
insert_node_into_singly_linked_list(&llist1, llist1_item);
}
SinglyLinkedList* llist2 = malloc(sizeof(SinglyLinkedList));
llist2->head = NULL;
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); }
insert_node_into_singly_linked_list(&llist2, llist2_item);
}
bool result = compare_lists(llist1->head, llist2->head);
fprintf(fptr, "%d\n", result);
}
fclose(fptr);
return 0;
}
char* readline() {
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 &
Try With Live Editor
#2 Code Example with C++ Programming
Code -
C++ Programming
#include <bits/stdc++.h>
using namespace std;
class SinglyLinkedListNode {
public:
int data;
SinglyLinkedListNode *next;
SinglyLinkedListNode(int node_data) {
this->data = node_data;
this->next = nullptr;
}
};
class SinglyLinkedList {
public:
SinglyLinkedListNode *head;
SinglyLinkedListNode *tail;
SinglyLinkedList() {
this->head = nullptr;
this->tail = nullptr;
}
void insert_node(int node_data) {
SinglyLinkedListNode* node = new SinglyLinkedListNode(node_data);
if (!this->head) {
this->head = node;
} 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;
}
}
}
void free_singly_linked_list(SinglyLinkedListNode* node) {
while (node) {
SinglyLinkedListNode* temp = node;
node = node->next;
free(temp);
}
}
bool compare_lists(SinglyLinkedListNode* head1, SinglyLinkedListNode* head2) {
int res=1;
while(head1 != NULL || head2 != NULL){
if(head1 == NULL) {res=0; break;}
if(head2 == NULL) {res=0; break;}
if(head1->data != head2->data){res=0;break;}
head1=head1->next;
head2=head2->next;
}
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++) {
SinglyLinkedList* llist1 = new SinglyLinkedList();
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);
}
SinglyLinkedList* llist2 = new SinglyLinkedList();
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);
}
bool result = compare_lists(llist1->head, llist2->head);
fout << result << "\n";
}
fout.close();
return 0;
}
Copy The Code &
Try With Live Editor
#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 {
static class SinglyLinkedListNode {
public int data;
public SinglyLinkedListNode next;
public SinglyLinkedListNode(int nodeData) {
this.data = nodeData;
this.next = null;
}
}
static class SinglyLinkedList {
public SinglyLinkedListNode head;
public SinglyLinkedListNode tail;
public SinglyLinkedList() {
this.head = null;
this.tail = null;
}
public void insertNode(int nodeData) {
SinglyLinkedListNode node = new SinglyLinkedListNode(nodeData);
if (this.head == null) {
this.head = node;
} 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);
}
}
}
static boolean compareLists(SinglyLinkedListNode head1, SinglyLinkedListNode head2) {
while((head1!=null && head2!=null) && head1.data == head2.data){
head1 = head1.next;
head2 = head2.next;
}
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++) {
SinglyLinkedList llist1 = new SinglyLinkedList();
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);
}
SinglyLinkedList llist2 = new SinglyLinkedList();
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);
}
boolean result = compareLists(llist1.head, llist2.head);
bufferedWriter.write(String.valueOf(result ? 1 : 0));
bufferedWriter.newLine();
}
bufferedWriter.close();
scanner.close();
}
}
Copy The Code &
Try With Live Editor
#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();
});
function readLine() {
return inputString[currentLine++];
}
const SinglyLinkedListNode = class {
constructor(nodeData) {
this.data = nodeData;
this.next = null;
}
};
const SinglyLinkedList = class {
constructor() {
this.head = null;
this.tail = null;
}
insertNode(nodeData) {
const node = new SinglyLinkedListNode(nodeData);
if (this.head == null) {
this.head = node;
} 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 CompareLists function below.
/*
* For your reference:
*
* SinglyLinkedListNode {
* int data;
* SinglyLinkedListNode next;
* }
*
*/
function CompareLists( headA, headB) {
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);
}
let result = CompareLists(llist1.head, llist2.head);
ws.write((result ? 1 : 0) + "\n");
}
ws.end(>;
}
Copy The Code &
Try With Live Editor
#5 Code Example with Python Programming
Code -
Python Programming
#!/bin/python3
import os
import sys
class SinglyLinkedListNode:
def __init__(self, node_data):
self.data = node_data
self.next = None
class SinglyLinkedList:
def __init__(self):
self.head = None
self.tail = None
def insert_node(self, node_data):
node = SinglyLinkedListNode(node_data)
if not self.head:
self.head = node
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 compare_lists function below.
#
# For your reference:
#
# SinglyLinkedListNode:
# int data
# SinglyLinkedListNode next
#
#
def compare_lists(headA, headB):
if headA is None:
return 1 if headB is None else 0
if headB is None:
return 0
if headA.data != headB.data:
return 0
else:
return compare_lists(headA.next, headB.next)
if __name__ == '__main__':
fptr = open(os.environ['OUTPUT_PATH'], 'w')
tests = int(input())
for tests_itr in range(tests):
llist1_count = int(input())
llist1 = SinglyLinkedList()
for _ in range(llist1_count):
llist1_item = int(input())
llist1.insert_node(llist1_item)
llist2_count = int(input())
llist2 = SinglyLinkedList()
for _ in range(llist2_count):
llist2_item = int(input())
llist2.insert_node(llist2_item)
result = compare_lists(llist1.head, llist2.head)
fptr.write(str(int(result)) + '\n')
fptr.close()
Copy The Code &
Try With Live Editor