## Sunday, 9 July 2017

### How to check if a Singly Linked List is a Palindrome or not

#### Background

This is another classic data structure interview question that fall into basic DS problems. You might have seen or known method to find if a String is palindrome or not. You can simply iterate on half of the String and check with reversed other half if it same.

Time Complexity : O(N)
Space Complexity : O(1)

It will be as simple as -

```    public static boolean isPalindrome(String str) {
if(str == null) {
return false;
}
for(int i = 0; i< str.length()/2; i++) {
if(!(str.charAt(i) == str.charAt(str.length() - i - 1))) {
return false;
}
}
return true;
}
```

Test :
System.out.println(isPalindrome("ABCDCBA"));
System.out.println(isPalindrome("ABBA"));
System.out.println(isPalindrome("ABCD"));
Output:
true
true
false

It can have a variant such that instead of a String you have a Linked List. Now if you have a double linked list it becomes very easy. You start from head and from the tails and keep comparing. Increment the header pointer and decrement the tail pointer in each iteration. Time complexity will be O(N) only.

However the question at hand is of Singly Linked List.

#### Method 1 : Using a String

Iterate over the Linked list and construct a String out of it and then check if that String is a Palindrome.Time complexity O(N) but space complexity is also O(N) since you are now creating a String.

Since interviewer asked you Linked List this is most definitely something he does not want. He could have asked a String palindrome itself if that was the case. But it never hurts to put it out what you are thinking and build upon your answer as you proceed.

#### Method 2 : Using a Stack

You can iterate over the Linked List put it's content in stack. Once iteration is over we can iterate over Linked List again and this time with each iteration compare Nodes content with Stacks popped out content. If it does not match it is not a palindrome.
This again has time complexity O(N) and space complexity O(N).

1) Traverse the given list from head to tail and push every visited node to stack.
2) Traverse the list again. For every visited node, pop a node from stack and compare data of popped node with currently visited node.
3) If all nodes matched, then return true, else false.

Code :

```    public static boolean isPalindrome(ListNode<String> head) {
boolean isPanindrome = true;

Stack<String> stack = new Stack<>();

while (currentNode != null) {
stack.push(currentNode.getValue());
currentNode = currentNode.getNext();
}

while (currentNode != null) {
if (!currentNode.getValue().equals(stack.pop())) {
isPanindrome = false;
break;
}
currentNode = currentNode.getNext();
}
return isPanindrome;
}
```

I have also added it to my Data Structure github repo. Check isPalindrome() method in  https://github.com/aniket91/DataStructures/blob/master/src/com/osfg/questions/LinkedListPalindromeFinder.java

#### Method 3 : Reversing the 2nd half of the Linked List

This is a better version and always one you should aim for. It provides O(N) time complexity and O(1) space complexity -

1) Get the middle of the linked list.
2) Reverse the second half of the linked list.
3) Check if the first half and second half are identical.
4) Construct the original linked list by reversing the second half again and attaching it back to the first half

4th point is optional and depends if you need original List back.

I have added it to my Data Structure github repo. Check isPalindrome2() method in  https://github.com/aniket91/DataStructures/blob/master/src/com/osfg/questions/LinkedListPalindromeFinder.java