[Algorithm] Palindrome 问题

9. Palindrome Number：点击打开链接

public class Solution {
    public boolean isPalindrome(int x) { //不同解题思维
        int temp = 0;
        int startX=x;
        while(x>0){
            temp = temp*10 + (x % 10);   //看temp最后是不是等于startX
            x = x/10; 
        }
        return temp==startX;             //因为x已经变化，所以最后要看temp==startX，也说明了一开始记录startX的重要性
    }
}

125. Valid Palindrome：点击打开链接

public class Solution {
    public boolean isPalindrome(String s) {
        String actual=s.replaceAll("[^A-Za-z0-9]","").toLowerCase();  //在这里转小写字母
        
        for(int i=0,j=actual.length()-1;i<j;i++,j--){
            if(actual.charAt(i)!=actual.charAt(j)){
                return false;
            }
        }
        return true;
    }
}

public class Solution {
    public boolean isPalindrome(String s) {
        String actual=s.replaceAll("[^A-Za-z0-9]","");
        
        for(int i=0,j=actual.length()-1;i<j;i++,j--){
            if(Character.toLowerCase(actual.charAt(i))!=Character.toLowerCase(actual.charAt(j))){ //或者这样
                return false;                                         //因为char没有toLowerCase的方法
            }
        }
        return true;
    }
}

public class Solution {
    public boolean isPalindrome(String s) {                                     //错误写法式样
        String actual=s.replaceAll("[^A-Za-z0-9]","");
        
        for(int i=0,j=actual.length()-1;i<j;i++,j--){
            if(actual.toLowerCase().charAt(i)!=actual.toLowerCase().charAt(j)){ //这样先转小写会报错：Time Limit Exceeded
                return false;                                                   //所以这样简单一个题，稍不注意就会出错
            }
        }
        return true;
    }
}

223. Palindrome Linked List：点击打开链接

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    /**
     * @param head a ListNode
     * @return a boolean
     */
    public boolean isPalindrome(ListNode head) {  //解法：将链表从中间分成两份，reverse第二份，依次比较两份的每一个ListNode值
        if(head==null){                           //有两种链表情况，但是都可以统一处理
           return true;                           //1->3->5->3->1处理成1->3->5->null，null<-3<-1，只比较到1和3，不比较5
        }                                         //1->3->3->1处理成1->3->null，null<-3<-1，比较1和3
       
        ListNode mid=findMiddle(head);
        ListNode secondHead=reverse(mid.next);
        
        ListNode p1=head,p2=secondHead;
        while(p1!=null && p2!=null){
            if(p1.val!=p2.val){                   //什么时候写if判断语句很重要                  
                return false;                     //如果写在p1=p1.next,p2=p2.next之后，就少判断了最开始p1.val==p2.val,报错
            }                                     //而Linked List Cycle，之后判断slow==fast，因为最开始两者值都是head.val
            p1=p1.next;
            p2=p2.next;
        }
        return true;
    }
    
    private ListNode findMiddle(ListNode head){
        ListNode slow=head;
        ListNode fast=head;
        while(fast.next!=null && fast.next.next!=null){
            slow=slow.next;
            fast=fast.next.next;
        }
        return slow;
    }
    
    private ListNode reverse(ListNode head){
        ListNode pre=null;
        while(head!=null){
            ListNode temp=head.next;
            head.next=pre;
            pre=head;
            head=temp;
        }
        return pre;
    }
}