GeeksforGeeks App
Open App
Browser
Continue

# Compare two strings represented as linked lists

Given two strings, represented as linked lists (every character is a node in a linked list). Write a function compare() that works similar to strcmp(), i.e., it returns 0 if both strings are the same, 1 if the first linked list is lexicographically greater, and -1 if the second string is lexicographically greater.

Examples:

Input: list1 = g->e->e->k->s->a
list2 = g->e->e->k->s->b
Output: -1
Explanation: “geeksb” is lexicographically greater than “geeksa”.

Input: list1 = g->e->e->k->s->a
list2 = g->e->e->k->s
Output: 1
Explanation: “geeksa” is greater than “geeks”.

Input: list1 = g->e->e->k->s
list2 = g->e->e->k->s
Output: 0
Explanation: Both the strings are “geeks”.

Naive Approach: Traverse the linked list and form the strings. Now compare the strings to check if both the strings are same or not.

Time Complexity: O(N + M) where N and M are the lengths of the linked lists.
Auxiliary Space: O(N + M)

Efficient Approach: An efficient approach is to use two pointer algorithm. Follow the steps mentioned below:

• Create two pointers and point to the starting of the linked lists.
• Traverse both the lists. If the characters are same keep traversing and increment both the pointers.
• If there is a mismatch:
• If character at that node of list1 is lexicographically greater print 1 and stop iteration.
• If character at that node of list2 is lexicographically greater print -1 and stop iteration.
• If traversal reaches the end of one of the list:
• If the end of the other list is also reached both strings are same.
• Else the other one is the lexicographically bigger one.

Below is the implementation of the above approach.

## C++

 `// C++ program to compare two strings ``// represented as linked lists``#include``using` `namespace` `std;``  ` `// Linked list Node structure``struct` `Node``{``    ``char` `c;``    ``struct` `Node *next;``};``  ` `// Function to create newNode in a linkedlist``Node* newNode(``char` `c)``{``    ``Node *temp = ``new` `Node;``    ``temp->c = c;``    ``temp->next = NULL;``    ``return` `temp;``};`` ` `int` `compare(Node *list1, Node *list2) ``{    ``    ``// Traverse both lists. Stop when ``    ``// either end of a linked list is reached ``    ``// or current characters don't match``    ``while` `(list1 && list2 && ``           ``list1->c == list2->c) ``    ``{         ``        ``list1 = list1->next;``        ``list2 = list2->next;``    ``}``     ` `    ``// If both lists are not empty, ``    ``// compare mismatching characters``    ``if` `(list1 && list2) ``        ``return` `(list1->c > list2->c)? 1: -1;`` ` `    ``// If either of the two lists ``    ``// has reached end``    ``if` `(list1 && !list2) ``return` `1;``    ``if` `(list2 && !list1) ``return` `-1;``     ` `    ``// If none of the above conditions is true,``    ``// both lists have reached end ``    ``return` `0;``}`` ` `// Driver code``int` `main()``{``    ``Node *list1 = newNode(``'g'``);``    ``list1->next = newNode(``'e'``);``    ``list1->next->next = newNode(``'e'``);``    ``list1->next->next->next = newNode(``'k'``);``    ``list1->next->next->next->next = ``        ``newNode(``'s'``);``    ``list1->next->next->next->next->next = ``        ``newNode(``'b'``);`` ` `    ``Node *list2 = newNode(``'g'``);``    ``list2->next = newNode(``'e'``);``    ``list2->next->next = newNode(``'e'``);``    ``list2->next->next->next = newNode(``'k'``);``    ``list2->next->next->next->next = ``        ``newNode(``'s'``);``    ``list2->next->next->next->next->next = ``        ``newNode(``'a'``);`` ` `    ``cout << compare(list1, list2);``    ``return` `0;``}`

## Java

 `// Java program to compare two strings represented as a linked list`` ` `// Linked List Class``class` `LinkedList {`` ` `    ``Node head;  ``// head of list``    ``static` `Node a, b;`` ` `    ``/* Node Class */``    ``static` `class` `Node {`` ` `        ``char` `data;``        ``Node next;`` ` `        ``// Constructor to create a new node``        ``Node(``char` `d) {``            ``data = d;``            ``next = ``null``;``        ``}``    ``}`` ` `    ``int` `compare(Node node1, Node node2) {`` ` `        ``if` `(node1 == ``null` `&& node2 == ``null``) {``            ``return` `1``;``        ``}``        ``while` `(node1 != ``null` `&& node2 != ``null` `&& node1.data == node2.data) {``            ``node1 = node1.next;``            ``node2 = node2.next;``        ``}`` ` `        ``// if the list are different in size``        ``if` `(node1 != ``null` `&& node2 != ``null``) {``            ``return` `(node1.data > node2.data ? ``1` `: -``1``);``        ``}`` ` `        ``// if either of the list has reached end``        ``if` `(node1 != ``null` `&& node2 == ``null``) {``            ``return` `1``;``        ``}``        ``if` `(node1 == ``null` `&& node2 != ``null``) {``            ``return` `-``1``;``        ``}``        ``return` `0``;``    ``}`` ` `    ``public` `static` `void` `main(String[] args) {`` ` `        ``LinkedList list = ``new` `LinkedList();``        ``Node result = ``null``;`` ` `        ``list.a = ``new` `Node(``'g'``);``        ``list.a.next = ``new` `Node(``'e'``);``        ``list.a.next.next = ``new` `Node(``'e'``);``        ``list.a.next.next.next = ``new` `Node(``'k'``);``        ``list.a.next.next.next.next = ``new` `Node(``'s'``);``        ``list.a.next.next.next.next.next = ``new` `Node(``'b'``);`` ` `        ``list.b = ``new` `Node(``'g'``);``        ``list.b.next = ``new` `Node(``'e'``);``        ``list.b.next.next = ``new` `Node(``'e'``);``        ``list.b.next.next.next = ``new` `Node(``'k'``);``        ``list.b.next.next.next.next = ``new` `Node(``'s'``);``        ``list.b.next.next.next.next.next = ``new` `Node(``'a'``);`` ` `        ``int` `value;``        ``value = list.compare(a, b);``        ``System.out.println(value);`` ` `    ``}``}`` ` `// This code has been contributed by Mayank Jaiswal`

## Python3

 `# Python program to compare two strings represented as``# linked lists`` ` `# A linked list node structure``class` `Node:`` ` `    ``# Constructor to create a new node``    ``def` `__init__(``self``, key):``        ``self``.c ``=` `key ; ``        ``self``.``next` `=` `None`` ` `def` `compare(list1, list2):``     ` `    ``# Traverse both lists. Stop when either end of linked ``    ``# list is reached or current characters don't match``    ``while``(list1 ``and` `list2 ``and` `list1.c ``=``=` `list2.c):``        ``list1 ``=` `list1.``next` `        ``list2 ``=` `list2.``next` ` ` `    ``# If both lists are not empty, compare mismatching``    ``# characters ``    ``if``(list1 ``and` `list2):``        ``return` `1` `if` `list1.c > list2.c ``else` `-``1` ` ` `    ``# If either of the two lists has reached end``    ``if` `(list1 ``and` `not` `list2):``        ``return` `1` ` ` `    ``if` `(list2 ``and` `not` `list1):``        ``return` `-``1` `    ``return` `0`` ` `# Driver program`` ` `list1 ``=` `Node(``'g'``)``list1.``next` `=` `Node(``'e'``)``list1.``next``.``next` `=` `Node(``'e'``)``list1.``next``.``next``.``next` `=` `Node(``'k'``)``list1.``next``.``next``.``next``.``next` `=` `Node(``'s'``)``list1.``next``.``next``.``next``.``next``.``next` `=` `Node(``'b'``)`` ` `list2 ``=` `Node(``'g'``)``list2.``next` `=` `Node(``'e'``)``list2.``next``.``next` `=` `Node(``'e'``)``list2.``next``.``next``.``next` `=` `Node(``'k'``)``list2.``next``.``next``.``next``.``next` `=` `Node(``'s'``)``list2.``next``.``next``.``next``.``next``.``next` `=` `Node(``'a'``)`` ` `print` `(compare(list1, list2))`` ` `# This code is contributed by Nikhil Kumar Singh(nickzuck_007)`

## C#

 `// C# program to compare two ``// strings represented as a linked list``using` `System;`` ` `// Linked List Class``public` `class` `LinkedList``{`` ` `    ``public` `Node head; ``// head of list``    ``public` `Node a, b;`` ` `    ``/* Node Class */``    ``public` `class` `Node ``    ``{`` ` `        ``public` `char` `data;``        ``public` `Node next;`` ` `        ``// Constructor to create a new node``        ``public` `Node(``char` `d) ``        ``{``            ``data = d;``            ``next = ``null``;``        ``}``    ``}`` ` `    ``int` `compare(Node node1, Node node2)``    ``{`` ` `        ``if` `(node1 == ``null` `&& node2 == ``null``) ``        ``{``            ``return` `1;``        ``}``        ``while` `(node1 != ``null` `&& ``                ``node2 != ``null` `&& ``                ``node1.data == node2.data)``        ``{``            ``node1 = node1.next;``            ``node2 = node2.next;``        ``}`` ` `        ``// if the list are different in size``        ``if` `(node1 != ``null` `&& node2 != ``null``) ``        ``{``            ``return` `(node1.data > node2.data ? 1 : -1);``        ``}`` ` `        ``// if either of the list has reached end``        ``if` `(node1 != ``null` `&& node2 == ``null``)``        ``{``            ``return` `1;``        ``}``        ``if` `(node1 == ``null` `&& node2 != ``null``)``        ``{``            ``return` `-1;``        ``}``        ``return` `0;``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args) ``    ``{`` ` `        ``LinkedList list = ``new` `LinkedList();`` ` `        ``list.a = ``new` `Node(``'g'``);``        ``list.a.next = ``new` `Node(``'e'``);``        ``list.a.next.next = ``new` `Node(``'e'``);``        ``list.a.next.next.next = ``new` `Node(``'k'``);``        ``list.a.next.next.next.next = ``new` `Node(``'s'``);``        ``list.a.next.next.next.next.next = ``new` `Node(``'b'``);`` ` `        ``list.b = ``new` `Node(``'g'``);``        ``list.b.next = ``new` `Node(``'e'``);``        ``list.b.next.next = ``new` `Node(``'e'``);``        ``list.b.next.next.next = ``new` `Node(``'k'``);``        ``list.b.next.next.next.next = ``new` `Node(``'s'``);``        ``list.b.next.next.next.next.next = ``new` `Node(``'a'``);`` ` `        ``int` `value;``        ``value = list.compare(list.a, list.b);``        ``Console.WriteLine(value);``    ``}``}`` ` `// This code contributed by Rajput-Ji`

## Javascript

 ``

Output

`1`

Time Complexity: O(N + M)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up