Two Linked Lists are identical when they have the same data and the arrangement of data is also the same. For example, Linked lists a (1->2->3) and b(1->2->3) are identical. . Write a function to check if the given two linked lists are identical.
Method 1 (Iterative) To identify if two lists are identical, we need to traverse both lists simultaneously, and while traversing we need to compare data.
C++
// An iterative C++ program to check if
// two linked lists are identical or not
#include<bits/stdc++.h>
usingnamespacestd;
/* Structure for a linked list node */
structNode
{
intdata;
structNode *next;
};
/* Returns true if linked lists a and b
are identical, otherwise false */
boolareIdentical(structNode *a,
structNode *b)
{
while(a != NULL && b != NULL)
{
if(a->data != b->data)
returnfalse;
/* If we reach here, then a and b are
not NULL and their data is same, so
move to next nodes in both lists */
a = a->next;
b = b->next;
}
// If linked lists are identical, then
// 'a' and 'b' must be NULL at this point.
return(a == NULL && b == NULL);
}
/* UTILITY FUNCTIONS TO TEST fun1() and fun2() */
/* Given a reference (pointer to pointer) to the
head of a list and an int, push a new node on the
front of the list. */
voidpush(structNode** head_ref, intnew_data)
{
/* allocate node */
structNode* new_node =
(structNode*) malloc(sizeof(structNode));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
// Driver Code
intmain()
{
/* The constructed linked lists are :
a: 3->2->1
b: 3->2->1 */
structNode *a = NULL;
structNode *b = NULL;
push(&a, 1);
push(&a, 2);
push(&a, 3);
push(&b, 1);
push(&b, 2);
push(&b, 3);
if(areIdentical(a, b))
cout << "Identical";
else
cout << "Not identical";
return0;
}
// This code is contributed
// by Akanksha Rai
C
// An iterative C program to check if two linked lists are
// identical or not
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
/* Structure for a linked list node */
structNode
{
intdata;
structNode *next;
};
/* Returns true if linked lists a and b are identical,
otherwise false */
boolareIdentical(structNode *a, structNode *b)
{
while(a != NULL && b != NULL)
{
if(a->data != b->data)
returnfalse;
/* If we reach here, then a and b are not NULL and
their data is same, so move to next nodes in both
lists */
a = a->next;
b = b->next;
}
// If linked lists are identical, then 'a' and 'b' must
// be NULL at this point.
return(a == NULL && b == NULL);
}
/* UTILITY FUNCTIONS TO TEST fun1() and fun2() */
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
voidpush(structNode** head_ref, intnew_data)
{
/* allocate node */
structNode* new_node =
(structNode*) malloc(sizeof(structNode));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Driver program to test above function */
intmain()
{
/* The constructed linked lists are :
a: 3->2->1
b: 3->2->1 */
structNode *a = NULL;
structNode *b = NULL;
push(&a, 1);
push(&a, 2);
push(&a, 3);
push(&b, 1);
push(&b, 2);
push(&b, 3);
areIdentical(a, b)? printf("Identical"):
printf("Not identical");
return0;
}
Java
// An iterative Java program to check if two linked lists
// are identical or not
classLinkedList
{
Node head; // head of list
/* Linked list Node*/
classNode
{
intdata;
Node next;
Node(intd) { data = d; next = null; }
}
/* Returns true if linked lists a and b are identical,
otherwise false */
booleanareIdentical(LinkedList listb)
{
Node a = this.head, b = listb.head;
while(a != null&& b != null)
{
if(a.data != b.data)
returnfalse;
/* If we reach here, then a and b are not null
and their data is same, so move to next nodes
in both lists */
a = a.next;
b = b.next;
}
// If linked lists are identical, then 'a' and 'b' must
// be null at this point.
return(a == null&& b == null);
}
/* UTILITY FUNCTIONS TO TEST fun1() and fun2() */
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
voidpush(intnew_data)
{
/* 1 & 2: Allocate the Node &
Put in the data*/
Node new_node = newNode(new_data);
/* 3. Make next of new Node as head */
new_node.next = head;
/* 4. Move the head to point to new Node */
head = new_node;
}
/* Driver program to test above functions */
publicstaticvoidmain(String args[])
{
LinkedList llist1 = newLinkedList();
LinkedList llist2 = newLinkedList();
/* The constructed linked lists are :
llist1: 3->2->1
llist2: 3->2->1 */
llist1.push(1);
llist1.push(2);
llist1.push(3);
llist2.push(1);
llist2.push(2);
llist2.push(3);
if(llist1.areIdentical(llist2) == true)
System.out.println("Identical ");
else
System.out.println("Not identical ");
}
} /* This code is contributed by Rajat Mishra */
Python3
# An iterative Java program to check if
# two linked lists are identical or not
# Linked list Node
classNode:
def__init__(self, d):
self.data =d
self.next=None
classLinkedList:
def__init__(self):
self.head =None# head of list
# Returns true if linked lists a and b
# are identical, otherwise false
defareIdentical(self, listb):
a =self.head
b =listb.head
while(a !=Noneandb !=None):
if(a.data !=b.data):
returnFalse
# If we reach here, then a and b
# are not null and their data is
# same, so move to next nodes
# in both lists
a =a.next
b =b.next
# If linked lists are identical,
# then 'a' and 'b' must be null
# at this point.
return(a ==Noneandb ==None)
# UTILITY FUNCTIONS TO TEST fun1() and fun2()
# Given a reference (pointer to pointer) to the
# head of a list and an int, push a new node on
# the front of the list.
defpush(self, new_data):
# 1 & 2: Allocate the Node &
# Put in the data
new_node =Node(new_data)
# 3. Make next of new Node as head
new_node.next=self.head
# 4. Move the head to point to new Node
self.head =new_node
# Driver Code
llist1 =LinkedList()
llist2 =LinkedList()
# The constructed linked lists are :
# llist1: 3->2->1
# llist2: 3->2->1
llist1.push(1)
llist1.push(2)
llist1.push(3)
llist2.push(1)
llist2.push(2)
llist2.push(3)
if(llist1.areIdentical(llist2) ==True):
print("Identical ")
else:
print("Not identical ")
# This code is contributed by Prerna Saini
C#
// An iterative C# program to
// check if two linked lists
// are identical or not
usingSystem;
publicclassLinkedList
{
Node head; // head of list
/* Linked list Node*/
publicclassNode
{
publicintdata;
publicNode next;
publicNode(intd)
{
data = d; next = null;
}
}
/* Returns true if linked lists
a and b are identical,
otherwise false */
boolareIdentical(LinkedList listb)
{
Node a = this.head, b = listb.head;
while(a != null&& b != null)
{
if(a.data != b.data)
returnfalse;
/* If we reach here, then a and b are not null
and their data is same, so move to next nodes
in both lists */
a = a.next;
b = b.next;
}
// If linked lists are identical,
// then 'a' and 'b' must
// be null at this point.
return(a == null&& b == null);
}
/* UTILITY FUNCTIONS TO TEST fun1() and fun2() */
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
voidpush(intnew_data)
{
/* 1 & 2: Allocate the Node &
Put in the data*/
Node new_node = newNode(new_data);
/* 3. Make next of new Node as head */
new_node.next = head;
/* 4. Move the head to point to new Node */
head = new_node;
}
/* Driver code */
publicstaticvoidMain(String []args)
{
LinkedList llist1 = newLinkedList();
LinkedList llist2 = newLinkedList();
/* The constructed linked lists are :
llist1: 3->2->1
llist2: 3->2->1 */
llist1.push(1);
llist1.push(2);
llist1.push(3);
llist2.push(1);
llist2.push(2);
llist2.push(3);
if(llist1.areIdentical(llist2) == true)
Console.WriteLine("Identical ");
else
Console.WriteLine("Not identical ");
}
}
// This code contributed by Rajput-Ji
Javascript
<script>
// An iterative javascript program to check if two linked lists
// are identical or not
class LinkedList{
constructor() {
this.head = null; // head of list
}
}
/* Linked list Node */
class Node {
constructor(d) {
this.data = d;
this.next = null;
}
}
/*
* Returns true if linked lists a and b are identical, otherwise false
*/
functionareIdentical( a,b) {
while(a != null&& b != null) {
if(a.data != b.data)
returnfalse;
/*
* If we reach here, then a and b are not null and their data is same, so move
* to next nodes in both lists
*/
a = a.next;
b = b.next;
}
// If linked lists are identical, then 'a' and 'b' must
// be null at this point.
return(a == null&& b == null);
}
/* UTILITY FUNCTIONS TO TEST fun1() and fun2() */
/*
* Given a reference (pointer to pointer) to the head of a list and an int, push
* a new node on the front of the list.
*/
functionpush(root,new_data) {
/*
* 1 & 2: Allocate the Node & Put in the data
*/
varnew_node = newNode(new_data);
/* 3. Make next of new Node as head */
new_node.next = root;
/* 4. Move the head to point to new Node */
root = new_node;
returnroot;
}
/* Driver program to test above functions */
varllist1 = newLinkedList();
varllist2 = newLinkedList();
/*
* The constructed linked lists are : llist1: 3->2->1 llist2: 3->2->1
*/
llist1 = push(llist1,1);
llist1 = push(llist1,2);
llist1 = push(llist1,3);
llist2 = push(llist2,1);
llist2 = push(llist2,2);
llist2 = push(llist2,3);
if(areIdentical(llist1,llist2) == true)
document.write("Identical ");
else
document.write("Not identical ");
// This code is contributed by Rajput-Ji
</script>
Output:
Identical
Time Complexity: O(min(m,n))
Here, m and n are the size of the two linked lists and we have to traverse till any one of them becomes null. So our time complexity will be minimum of the size of two linked lists.
Auxiliary Space: O(1)
As constant extra space is used.
Method 2 (Recursive) Recursive solution code is much cleaner than iterative code. You probably wouldn’t want to use the recursive version for production code, however, because it will use stack space which is proportional to the length of the lists
C++
// A recursive C++ function to check if two linked
// lists are identical or not
boolareIdentical(Node *a, Node *b)
{
// If both lists are empty
if(a == NULL && b == NULL)
returntrue;
// If both lists are not empty, then data of
// current nodes must match, and same should
// be recursively true for rest of the nodes.
if(a != NULL && b != NULL)
return(a->data == b->data) &&
areIdentical(a->next, b->next);
// If we reach here, then one of the lists
// is empty and other is not
returnfalse;
}
//This is code is contributed by rathbhupendra
C
// A recursive C function to check if two linked
// lists are identical or not
boolareIdentical(structNode *a, structNode *b)
{
// If both lists are empty
if(a == NULL && b == NULL)
returntrue;
// If both lists are not empty, then data of
// current nodes must match, and same should
// be recursively true for rest of the nodes.
if(a != NULL && b != NULL)
return(a->data == b->data) &&
areIdentical(a->next, b->next);
// If we reach here, then one of the lists
// is empty and other is not
returnfalse;
}
Java
// A recursive Java method to check if two linked
// lists are identical or not
booleanareIdenticalRecur(Node a, Node b)
{
// If both lists are empty
if(a == null&& b == null)
returntrue;
// If both lists are not empty, then data of
// current nodes must match, and same should
// be recursively true for rest of the nodes.
if(a != null&& b != null)
return(a.data == b.data) &&
areIdenticalRecur(a.next, b.next);
// If we reach here, then one of the lists
// is empty and other is not
returnfalse;
}
/* Returns true if linked lists a and b are identical,
otherwise false */
booleanareIdentical(LinkedList listb)
{
returnareIdenticalRecur(this.head, listb.head);
}
Python3
# A recursive Python3 function to check
# if two linked lists are identical or not
defareIdentical(a, b):
# If both lists are empty
if(a ==Noneandb ==None):
returnTrue
# If both lists are not empty,
# then data of current nodes must match,
# and same should be recursively true
# for rest of the nodes.
if(a !=Noneandb !=None):
return((a.data ==b.data) and
areIdentical(a.next, b.next))
# If we reach here, then one of the lists
# is empty and other is not
returnFalse
# This code is contributed by Princi Singh
C#
// A recursive C# method to
// check if two linked lists
// are identical or not
boolareIdenticalRecur(Node a, Node b)
{
// If both lists are empty
if(a == null&& b == null)
returntrue;
// If both lists are not empty, then data of
// current nodes must match, and same should
// be recursively true for rest of the nodes.
if(a != null&& b != null)
return(a.data == b.data) &&
areIdenticalRecur(a.next, b.next);
// If we reach here, then one of the lists
// is empty and other is not
returnfalse;
}
/* Returns true if linked lists
a and b are identical, otherwise false */
boolareIdentical(LinkedList listb)
{
returnareIdenticalRecur(this.head, listb.head);
}
}
// This code is contributed by princiraj1992
Javascript
<script>
// A recursive javascript method to check if two linked
// lists are identical or not
functionareIdenticalRecur( a, b)
{
// If both lists are empty
if(a == null&& b == null)
returntrue;
// If both lists are not empty, then data of
// current nodes must match, and same should
// be recursively true for rest of the nodes.
if(a != null&& b != null)
return(a.data == b.data) &&
areIdenticalRecur(a.next, b.next);
// If we reach here, then one of the lists
// is empty and other is not
returnfalse;
}
/* Returns true if linked lists a and b are identical,
otherwise false */
functionareIdentical( listb)
{
returnareIdenticalRecur(this.head, listb.head);
}
// This code contributed by aashish1995
</script>
Time Complexity: O(n)
Here, n is the length of the smaller list among a and b.
Auxiliary Space: O(n)
The extra space is used in recursion call stack.
Please write comments if you find the above codes/algorithms incorrect, or find better ways to solve the same problem.
We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
Privacy Policy