leetcode5-Longest Palindromic Substring

1,自己python解法（但是超时了）---复杂度：n^3

class Solution(object):
    def longestPalindrome(self, s):
        a=len(s)
        m=0
        if a==1:#1后面直接把j当做大于i用，所以要判断这个
            return s
        ans=s[0]#2后面return出的ans要初始化，否则if中一直没执行的话就出错
        for i in range(a):
            for j in range(a)[i+1:][::-1]:
                if s[i]==s[j] and  m<(j-i+1) and self.yesornot(s[i:j+1]):#类里面记得要加self来调用函数
                    ans=s[i:j+1]
                    m=j-i+1
                    break
        return ans
                    
                    
                
        
    def yesornot(self,s):
        a=len(s)
        i=0
        j=a-1
        while(i<=j):
            if s[i]==s[j]:
                i+=1
                j-=1
            else:
                break
        if i<=j:
            return False
        else:
            return True
                
        

注：3个标记处的收获

2,python解法---时间复杂度：n^2

class Solution(object):
    def longestPalindrome(self, s):
        a=len(s)
        start=0
        length=0
        for i in range(a-1):
            if s[i]==s[i+1]:
                b=self.panduan(s,i,i+1,length)
                if [-1,-1]!=b:
                    start,length=b
            
            b=self.panduan(s,i,i,length)
            if [-1,-1]!=b:
                    start,length=b
        if length==0:
            return s[0]
        return s[start:start+length]
        
                    
                
    def panduan(self,s,left,right,length):
        a=len(s)
        step=1
        while left-step>=0 and right+step<a:
            if s[left-step]!=s[right+step]:
                break
            step+=1
        if length<right-left+2*step-1:
            return [left-step+1,right-left+2*step-1]#-------------此处减1是因为相当于2*（step-1）+1
        else:
            return [-1,-1]
        
        

解法2和1的区别：解法1的时间复杂度：n个字符，每个字符找n次，每找到个相等的就会有个O(n)函数看是否回文。----O(n^3)

解法2的时间复杂度：n个字符，每个字符最多2次执行O(n)即O(2n)次，从而O(n^2)次

两者的区别就是解法2中将1中不必要的判断去掉了

3，java解法--和2的原理一样

public String longestPalindrome(String s) {
    int start = 0, end = 0;
    for (int i = 0; i < s.length(); i++) {
        int len1 = expandAroundCenter(s, i, i);
        int len2 = expandAroundCenter(s, i, i + 1);
        int len = Math.max(len1, len2);
        if (len > end - start) {//--------------------------------1
            start = i - (len - 1) / 2;
            end = i + len / 2;
        }
    }
    return s.substring(start, end + 1);
}

private int expandAroundCenter(String s, int left, int right) {
    int L = left, R = right;
    while (L >= 0 && R < s.length() && s.charAt(L) == s.charAt(R)) {
        L--;
        R++;
    }
    return R - L - 1;//---------------2
}

注意：标志1，学习这种用法；

标志2，相当于：(R-1)-(L+1)+1----对于上面有循环的，应该注意循环结束后参数改变，还是参数改变后循环结束