Check if a linked list of strings forms a palindrome
Last Updated :
26 Dec, 2022
Given a linked list handling string data, check to see whether data is palindrome or not?
For example,
Input : a -> bc -> d -> dcb -> a -> NULL
Output : True
String "abcddcba" is palindrome.
Output : a -> bc -> d -> ba -> NULL
Output : False
String "abcdba" is not palindrome.
The idea is very simple. Construct a string out of given linked list and check if the constructed string is palindrome or not.
C++
#include <bits/stdc++.h>
using namespace std;
struct Node
{
string data;
Node* next;
};
bool isPalindromeUtil(string str)
{
int length = str.length();
for ( int i=0; i<length/2; i++)
if (str[i] != str[length-i-1])
return false ;
return true ;
}
bool isPalindrome(Node *node)
{
string str = "" ;
while (node != NULL)
{
str.append(node->data);
node = node->next;
}
return isPalindromeUtil(str);
}
void printList(Node *node)
{
while (node != NULL)
{
cout << node->data << " -> " ;
node = node->next;
}
printf ( "NULL\n" );
}
Node *newNode( const char *str)
{
Node *new_node = new Node;
new_node->data = str;
new_node->next = NULL;
return new_node;
}
int main()
{
Node *head = newNode( "a" );
head->next = newNode( "bc" );
head->next->next = newNode( "d" );
head->next->next->next = newNode( "dcb" );
head->next->next->next->next = newNode( "a" );
isPalindrome(head)? printf ( "true\n" ):
printf ( "false\n" );
return 0;
}
|
Java
import java.util.Scanner;
class Node
{
String data;
Node next;
Node(String d)
{
data = d;
next = null ;
}
}
class LinkedList_Palindrome
{
Node head;
boolean isPalidromeUtil(String str)
{
int length = str.length();
for ( int i= 0 ; i<length/ 2 ; i++)
if (str.charAt(i) != str.charAt(length-i- 1 ))
return false ;
return true ;
}
boolean isPalindrome()
{
Node node = head;
String str = "" ;
while (node != null )
{
str = str.concat(node.data);
node = node.next;
}
return isPalidromeUtil(str);
}
public static void main(String[] args)
{
LinkedList_Palindrome list = new LinkedList_Palindrome();
list.head = new Node( "a" );
list.head.next = new Node( "bc" );
list.head.next.next = new Node( "d" );
list.head.next.next.next = new Node( "dcb" );
list.head.next.next.next.next = new Node( "a" );
System.out.println(list.isPalindrome());
}
}
|
Python3
class Node:
def __init__( self , data):
self .data = data
self . next = None
class LinkedList:
def __init__( self ):
self .head = None
def isPalindromeUtil( self , string):
return (string = = string[:: - 1 ])
def isPalindrome( self ):
node = self .head
temp = []
while (node is not None ):
temp.append(node.data)
node = node. next
string = "".join(temp)
return self .isPalindromeUtil(string)
def printList( self ):
temp = self .head
while (temp):
print (temp.data,end = " " )
temp = temp. next
llist = LinkedList()
llist.head = Node( 'a' )
llist.head. next = Node( 'bc' )
llist.head. next . next = Node( "d" )
llist.head. next . next . next = Node( "dcb" )
llist.head. next . next . next . next = Node( "a" )
print ( "true" if llist.isPalindrome() else "false" )
|
C#
using System;
class Node
{
public String data;
public Node next;
public Node(String d)
{
data = d;
next = null ;
}
}
public class LinkedList_Palindrome
{
Node head;
bool isPalidromeUtil(String str)
{
int length = str.Length;
for ( int i = 0; i < length / 2; i++)
if (str[i] != str[length - i - 1])
return false ;
return true ;
}
bool isPalindrome()
{
Node node = head;
String str = "" ;
while (node != null )
{
str = str+(node.data);
node = node.next;
}
return isPalidromeUtil(str);
}
public static void Main(String[] args)
{
LinkedList_Palindrome list = new LinkedList_Palindrome();
list.head = new Node( "a" );
list.head.next = new Node( "bc" );
list.head.next.next = new Node( "d" );
list.head.next.next.next = new Node( "dcb" );
list.head.next.next.next.next = new Node( "a" );
Console.WriteLine(list.isPalindrome());
}
}
|
Javascript
<script>
var head;
class Node{
constructor(val){
this .data = val;
this .next = null ;
}
}
function isPalindromeUtil(str){
var length = str.length;
for ( var i = 0; i<length/2; i++){
if (str[i] != str[length-i-1])
return false ;
}
return true ;
}
function isPalindrome(node){
var str = "" ;
while (node != null ){
str += node.data;
node = node.next;
}
return isPalindromeUtil(str);
}
function printList(node)
{
while (node != null )
{
console.log(node.data + " " );
node = node.next;
}
}
head = new Node( "a" );
head.next = new Node( "bc" );
head.next.next = new Node( "d" );
head.next.next.next = new Node( "dcb" );
head.next.next.next.next = new Node( "a" );
isPalindrome(head) ? console.log( "true" ) : console.log( "false" );
</script>
|
Time Complexity: O(n), where n is the number of nodes in the given linked list.
Auxiliary Space: O(m), where m is the length of the string formed by the linked list.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...