反转链表会影响 main() 中原始链表的头指针。 所以无法比较反向列表和原始列表 - C++

Question

I am writing a program to check whether a singly linked list is a palindrome or not. For that, I want to reverse the list, and compare it to the original list. But I am facing the following problem - when I reverse the list, the head pointer of the original list gets modified, and points to NULL. So, when I have the following original list, following happens after reversing the original list:

1. Original list: 1->1->2->1->NULL
2. Reversed list: 1->2->1->1->NULL
3. But, after calling reverseList, the Original list becomes: 1->NULL

This is, because I have the following code to reverse the list:

 ListNode* reverseList(ListNode* head)
 {
     ListNode* temp = head;
     ListNode* temp1 = temp;
     ListNode* current = NULL, * nextNode = NULL;
     if (temp)
         current = temp->next;
     if (current)
         nextNode = current->next;
     while (current)
     {
         current->next = temp;
         temp = current;
         current = nextNode;
         if (current)
             nextNode = current->next;
     }
     temp1->next = NULL;
     return temp;
 }

As soon as I do temp1->next = NULL in the above reverseList function (the second last line in the function), the head of the original list is modified and the original list now points to 1->NULL, instead of 1->1->2->1->NULL.

Below if the full code, that calls the function reverseList:

 struct ListNode
 {
     int val;
     ListNode* next;
     ListNode(int x):val(x),next(NULL){}
 };

 ListNode* reverseList(ListNode* head)
 {
     ListNode* temp = head;
     ListNode* temp1 = temp;
     ListNode* current = NULL, * nextNode = NULL;
     if (temp)
         current = temp->next;
     if (current)
         nextNode = current->next;
     while (current)
     {
         current->next = temp;
         temp = current;
         current = nextNode;
         if (current)
             nextNode = current->next;
     }
     temp1->next = NULL;
     return temp;
 }

 bool isPalindrome(ListNode* head) {
     //reverse the Linked list and then compare the two lists.
     if (head == NULL)
         return true;
     ListNode* head1 = head;
     ListNode* head2 = reverseList(head);
     while (head1 && head2)
     {
         if (head1->val != head2->val)
             return false;
         head1 = head1->next;
         head2 = head2->next;
     }
     return true;
 }

 int main()
 {
     ListNode* head = new ListNode(1);
     head->next = new ListNode(1);
     head->next->next = new ListNode(2);
     head->next->next->next = new ListNode(1);
     head->next->next->next->next = NULL;
     bool palindrome = isPalindrome(head);
     cout << palindrome << endl;
     return 0;
 }

So, when the reverseList function returns, following happens in isPalindrome function:

1. head2 is set to: 1->2->1->1->NULL
2. head and head1 are set to 1->NULL

And I can no longer compare the two linked lists to check if they are palindromes of each other (since the comparison will give me wrong result).

This all is happening because I set temp1->next=NULL in the reverseList function.

Do you know how I should properly terminate the list in reverseList function, such that it does not effect the original list?

Thanks a lot!

Answer 1

Following is the corrected code, where I incorporated the Deep Copy of the original list (in isPalindrome function):

 struct ListNode
 {
     int val;
     ListNode* next;
     ListNode(int x):val(x),next(NULL){}
 };

 ListNode* reverseList(ListNode* head)
 {
     ListNode* temp = head;
     ListNode* temp1 = temp;
     ListNode* current = NULL, * nextNode = NULL;
     if (temp)
         current = temp->next;
     if (current)
         nextNode = current->next;
     while (current)
     {
         current->next = temp;
         temp = current;
         current = nextNode;
         if (current)
             nextNode = current->next;
     }
     temp1->next = NULL;
     return temp;
 }

 bool isPalindrome(ListNode* head) {
     //reverse the Linked list and then compare the two lists.
     if (head == NULL)
         return true;
     ListNode* head1 = head;
     ListNode* temp1 = NULL, *temp2=NULL;
     bool firstEntry = true;

     //Deep Copy
     temp2 = temp1 = new ListNode(head1->val);
     while (head1->next)
     {
         temp1->next = new ListNode(head1->next->val);
         temp1 = temp1->next;
         head1 = head1->next;
     }

     temp1->next = NULL;
     ListNode* head2 = reverseList(head);
     while (temp2 && head2)
     {
         if (temp2->val != head2->val)
             return false;
         temp2 = temp2->next;
         head2 = head2->next;
     }
     return true;
 }

 int main()
 {
     ListNode* head = new ListNode(1);
     head->next = new ListNode(1);
     head->next->next = new ListNode(2);
     head->next->next->next = new ListNode(1);
     head->next->next->next->next = NULL;
     bool palindrome = isPalindrome(head);
     cout << palindrome << endl;
     return 0;
 }