Palindrome Linked List

1. The idea is to traverse the Linked List from head to tail and push every encountered node data into the stack.
2. 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.

1. The idea is to create a clone of Linked List and reverse it.
2. Now traverse both the Linked List and for each node data, we compare it, if they mismatch then the Linked List is not palindrome else if all elements match then the linked list is a palindrome.

1. 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.
2. In each recursion call, we check
   • Sub Linked list is a palindrome or not.
   • Values at the current left and right are matching.
3. If both above conditions are true then return true from the current recursion.
4. At last, if all the recursion calls return true. We can conclude the given Linked List is a palindrome.

Steps:

1. Recursively traverse the entire linked list to get the last node as a rightmost node.
2. 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.
3. 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 which passes in the function parameter of recursion.
4. 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.
5. If all the recursive calls are returning true, it means the given Linked List is a palindrome else it is not a palindrome.

1. We divide the Linked list into two equal halves by finding the middle node of Linked List
2. 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.
3. 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).
4. 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.
5. Then we reverse the second half of the Linked List.
6. 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.