Palindrome Linked List Question - Algorithm - algorithm

Question

class PalindromicLinkedList {
public static boolean isPalindrome(ListNode head) {
if (head == null || head.next == null)
return true;
// find middle of the LinkedList
ListNode slow = head;
ListNode fast = head;
while (fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
}
ListNode headSecondHalf = reverse(slow); // reverse the second half
ListNode copyHeadSecondHalf = headSecondHalf; // store the head of reversed part to revert back later
ListNode start = head;
// compare the first and the second half
while (start != null && headSecondHalf != null) {
if (start.value != headSecondHalf.value) {
return false; // not a palindrome
}
start = start.next;
headSecondHalf = headSecondHalf.next;
}
reverse(copyHeadSecondHalf); // revert the reverse of the second half
return true;
}
private static ListNode reverse(ListNode head) {
ListNode prev = null;
while (head != null) {
ListNode next = head.next;
head.next = prev;
prev = head;
head = next;
}
return prev;
}
}
}
This is palindrome linked-list question
Given the head of a Singly LinkedList, write a method to check if the
LinkedList is a palindrome or not.
Your algorithm should use constant space and the input LinkedList should be in the original form once the algorithm is finished. The algorithm should have O(N)O(N) time complexity where ‘N’ is the number of nodes in the LinkedList.
Above code is the solution for this problem,
and I understand most part of it but only have trouble to understand
reverse(copyHeadSecondHalf);
I just may guess this is for the algorithm condition which is that
input LinkedList should be in the original form once the algorithm is finished.
But Above code,
Have we ever changed or modified input LinkedList?
Everytime we just defined new ListNode pointing to the head reference
or some other ones.
Likewise, we just have new variable "headSecondHalf" to have new reversed version LinkedList.
and even we did nothing on copyHeadSecondHalf.
but why should we have
reverse(copyHeadSecondHalf);

Answer 1

But Above code, Have we ever changed or modified input LinkedList? Every time we just defined new ListNode pointing to the head reference or some other ones.
Yes, the original LinkedList is modified.
ListNode headSecondHalf = reverse(slow); // reverse the second half
The above line takes the middle of the LinkedList as input and reverses it. As a result, the structure of LinkedList is changed.
Ex: 5 → 2 → 3 → 2* → 5*
The slow pointer is at position 3.
Now, headSecondHalf points to 5* → 2* → 3
And original list becomes 5 → 2 → 3 (only half of the list) as 3 is pointing to NULL because of the reverse operation.
Likewise, we just have new variable "headSecondHalf" to have new reversed version LinkedList. and even we did nothing on copyHeadSecondHalf.
The headSecondHalf variable is used to check if the list is a palindrome. This means that the position is altered. For this reason, the value is copied to copyHeadSecondHalf, which is reversed again so that the original list is restored.

Answer 2

Consider following example linked list
1->2->3->4->2'->1'->NULL
in the first reverse, we get a new linked list as follows
1'->2'->4->NULL
The original linked list would be as follows
1->2->3->4->NULL
After comparison, we need to restore the linked list as per one of the condition. Hence the reverse step.
However, in the code, while returning false, this last step is not performed, breaking this rule. Hence either you add reverse before returning, or break the while loop, reverse and return at the end