[leetcode]5. Longest Palindromic Substring

Given a string S, find the longest palindromic substring in S. You may assume that the maximum length of S is 1000, and there exists one unique longest palindromic substring.

本题是求一个字符串的最长的回文子串。解题思路是遍历每一个字符和每一个字符之间的空隙，然后以当前字符或者空隙为中心向两边搜索，直到两个搜索点之间的字符串不是回文为止。

java代码

public class Solution {
    public String longestPalindrome(String s) {
        
        char[] a=s.toCharArray();
        int start=0,end=0,max=0;
        for(int i=0;i<a.length;i++)
        {
            int ss=i,e=i;
            while(ss>=0&&e<=a.length-1&&a[ss]==a[e])
            {
                ss--;
                e++;
            }
            ++ss;
            --e;
            if((e-ss)>=max)
            {
                max=e-ss;
                start=ss;
                end=e;
            }
            int ss1=i,e1=i+1;
            while(ss1>=0&&e1<=a.length-1&&a[ss1]==a[e1])
            {
                ss1--;
                e1++;
            }
            ++ss1;
            --e1;
            if(e1-ss1>max)
            {
                max=e1-ss1;
                start=ss1;
                end=e1;
            }
        }
        return s.substring(start,end+1);
    }
}

go代码

func longestPalindrome(s string) string {
    if len(s)<=1{
        return s
    }
    var i int
    var start,end int
    var max int
    var index1,index2 int
    for{
        if i==len(s){
            break
        }
        start=i
        end=i
        for{
            if start==-1||end==len(s){
                break
            }
            if s[start]==s[end]{
                if (end-start+1)>max{
                    max=end-start+1
                    index1=start
                    index2=end
                }
                start--
                end++
            }else{
                break
            }
        }
        
        start=i
        end=i+1
        for{
            if start==-1||end==len(s){
                break
            }
            if s[start]==s[end]{
                if (end-start+1)>max{
                    max=end-start+1
                    index1=start
                    index2=end
                }
                start--
                end++
            }else{
                break
            }
        }
        i++
    }
    return s[index1:index2+1]
}