# Palindrome Linked List

Posted: 16 Oct, 2020

Difficulty: Easy

#### You are given a singly Linked List of integers. Your task is to return true if the given singly linked list is a palindrome otherwise returns false.

##### For example:

```
The given linked list is 1 -> 2 -> 3 -> 2-> 1-> NULL.
It is a palindrome linked list because the given linked list has the same order of elements when traversed forwards and backward.
```

##### Follow Up:

```
Can you solve the problem in O(N) time complexity and O(1) space complexity iteratively?
```

##### Input format :

```
The first line of input contains an integer 'T' representing the number of test cases or queries to be processed. Then the test case follows.
The only line of each test case contains the elements of the singly linked list separated by a single space and terminated by -1. Hence, -1 would never be a list element.
```

##### Output format :

```
For each test case, print “true” or “false” in a separate line.
```

##### Note :

```
You do not need to print anything, it has already been taken care of. Just implement the given function.
```

##### Constraints :

```
1 <= T <= 10
0 <= L <= 10^5
1 <= data <= 10^9 and data != -1
Where L is the number of nodes in the Linked List.
Time Limit: 1 sec
```

Approach 1

- The idea is to traverse the Linked List from head to tail and push every encountered node data into the stack.
- Then we traverse the Linked List and for each node, we pop the top element from the stack and compare it with current node data of the Linked List. If they mismatch then the current linked list is not palindrome else if all elements match then the linked list is a palindrome.

Approach 2

Approach 3

- The solution is to use a recursion stack. We will use two pointers
**left**and**right**, one for the leftmost node and one for the rightmost node, of Linked List. - In each recursion call, we check
- Sub Linked list is a palindrome or not.
- Values at the current left and right are matching.

- If both above conditions are true then return true from the current recursion.
- At last, if all the recursion calls return true. We can conclude the given Linked List is a palindrome.

**Steps:**

- Recursively traverse the entire linked list to get the last node as a rightmost node.
- When we return from the last recursion stack. We will be at the last node of the Linked List. Then the last node value is compared with the first node value of Linked List.
- In order to access the first node of Linked List, we create a global
**left**pointer that points to the head of Linked List initially that will be available for every call of recursion and the**right**pointer - Now, if the
**left**and**right**pointer node value is matched then return true from the current recursion call. Then the recursion falls back to (n-2)th node, and then we need a reference to the 2nd node from head. So we advance the**left**pointer in the previous call to refer to the next node in the Linked List. - If all the recursive calls are returning true, it means the given Linked List is a palindrome else it is not a palindrome.

Approach 4

- We divide the Linked list into two equal halves by finding the middle node of Linked List
- To find the middle of the Linked List, we will create two pointers
**slow**and**fast**which will point to the head of the given Linked List initially. - Then we will iterate the given Linked List using these pointers
**slow**, and**fast**until the**fast**doesn't reach the end of Linked List and do the following in every step of the iteration:- slow = slow.next
- fast = fast.next.next (the fast pointer will take a jump of 2 in each step. Thus when fast reaches the end of the linked list then the slow pointer will be either at the mid or near to the mid of the linked list).

**Note:**- When the number of nodes is even then the first and second half contains equal nodes.
- But when the number of nodes is odd then there is one middle node so we don't consider it in both halves of Linked List.

- Then we reverse the second half of the Linked List.
- Now, we will compare the second half with the first half. If both the halves are exactly the same then the linked list is a palindrome, otherwise not.

SIMILAR PROBLEMS

# Print All Subsets

Posted: 23 Jul, 2021

Difficulty: Easy

# Implement a Queue

Posted: 27 Jul, 2021

Difficulty: Easy

# Vertical Sum in BST

Posted: 27 Jul, 2021

Difficulty: Moderate

# Remove Duplicates From Sorted List

Posted: 21 Sep, 2021

Difficulty: Easy

# Binary Linked List To Integer

Posted: 22 Sep, 2021

Difficulty: Easy