对一段可递归检查链接列表是否为回文的代码感到好奇

Question

bool isPalindromeUtil(struct node **left, struct  node *right)
{
   /* stop recursion when right becomes NULL */
   if (right == NULL)
      return true;

   /* If sub-list is not palindrome then no need to
       check for current left and right, return false */
   bool isp = isPalindromeUtil(left, right->next);
   if (isp == false)
      return false;

   /* Check values at current left and right */
   bool isp1 = (right->data == (*left)->data);

   /* Move left to next node */
   *left = (*left)->next;

   return isp1;
}

// A wrapper over isPalindromeUtil()
bool isPalindrome(struct node *head)
{
   isPalindromeUtil(&head, head);
}

look, when the left pointer and right pointer meet at the middle of the list in case when the link list contains odd no. of nodes, can't we terminate the recurrence faster by setting a flag equal to true if the cross- over between left and right pointers has already happened and then if the flag is true, we can directly return true without having to go through all those case checks??

@m ohem , my question was whether we could short circuit the process of returning true when the pointers have crossed over by making them set a global flag to true once the cross-over occurs..this short circuits the recursion without having to use the jmp operation that you suggested

Answer 1

Your function is recursive. It first recurses to the end of the list, such that left is at the list's head and right is at its tail. When it returns fom the recursion, it does the actual palindrome checking. The value of right walks backwards as the recursin unwinds and left walks forwards. This has to happen via a pointer reference, so that other instances of the recursive functions see the change.

The recursion provides a stack for the previous values of right , because your singly-linked list can't walk backwards without keeping track of where it's been.

Now about your question. You are basically right: It does not make sense to check the letters twice. But the recursion has gone all the way up; it also has to go all the way down. It can short-circuit the test once one of the tests is false (although it still has to pass the false value down until isPalindrome is reached), but if the word is a palindrome, everything is checked twice.

If you are feeling bold, you can try to jump out of the recursion with longjmp and setjmp , but you probably don't want that. What you want is a doubly-linked list that you can traverse in opposite directions in a loop. If your two pointers cross, just break out of the loop.