数据结构之回文专题（Palindrome）

   今日整理数据结构时正好遇到了回文专题，接下来我们会选典型的回文数、回文单链表、回文子串进行探讨，编程语言随机为C或者java.
   首先我们来看回文数，如何判断一个整数位回文数呢？小白我的理解应该是：121,212,313,2222,44444，之类的整数应该为回文数。现在我们要用code来判断回文数。
   分析：要考虑溢出情况，我们在进行数字处理时肯定会用到除法、求余等操作。代码比较简单直接看下面。

        bool isPalindromeNumber(int x) {
           int a  = x;
           int h = 1;
           if(a < 0) {
              return false;
              }
              // 找到最高位的h
              while(a/h >=10) {
                 h = h * 10;
                 } 
                 while(a > 0) {
                    // 首位和末尾数值对比
                    if(a/h)!= a %10){
                       return false;
                       }
                     a = a %10;   // 去掉最低位
                     a = a % h ;  // 去掉最高位
                      h = h / 100;
                      }
               return true;
                      }

   这样整个过程结束，注意我们是怎么样计算出 最高的h位以及 怎么将整数a去头去尾。

接下来看：回文单链表
如何判断一个单链表是否为回文单链表呢，网上有很多种解法，类似于用栈，以及数组存储法，此处不做过多讨论，读者可自行分析。我们这里采用链表翻转法。
分析： 我们找到链表的中间点，然后开始翻转后半部分链表，再比较前半部分和后半部分就可以得出结果，首先我们要解决链表反转问题。

    struct  ListNode {
            int val;
            struct ListNode *next;
            }
       struct ListNode* reverseList(struct ListNode* head)
       {
          if(NULL == head) {
              return head;
           }
           struct ListNode*  p = head;
           p = head->next;
           head->next = NULL; // 注意头结点的尾指针
           while(p!=NULL){
               struct ListNode*  ptmp = p->next;
               p->next = head;
               head = p;
               p = ptmp;
               }
               return head;
               }
               好了，齐活了，链表翻转搞定

现在正式开始解决回文链表判定的函数，那么问题来了，怎么搞呢，怎么找到链表的中间结点呢，这里我们设置两个指针一个快一个慢。

bool  isPalindromLinkList(struct ListNode*  head)
{
      if(head || head ->next){
          return true;
          }
          ListNode  *slow,*fast;
          slow = fast = head;
          while(fast&& fast->next){
            slow = slow ->next;
            fast = fast->next->next;
            }
       if(fast){
            slow->next = reverseList(slow->next);
            slow = slow->next;
            }
            else{
              slow = reverseList(slow);
              }
              while(slow){
                 if(head->val != slow->val){
                       return false;
                       }
                       slow = slow ->next;
                       head = head->next;
                       }
             return true;
}

搞定了，是不是很简单的对了，为什么我要对fast是否为空进行判断呢？仔细想想。