JAVA实现查找最长回文子串

题目：

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

方法一：采用滑动窗口，较为简单，但用时长。

public String longestPalindrome(String s) {
        if(s.length() == 1 || s.length() == 0){ //判断单字符串和空字符串
            return s;
        }
        String longest = String.valueOf(s.charAt(0));
        for(int i = 0; i < s.length(); i++){ // 两次循环遍历可能字符子串
            for(int j = i + 2; j <= s.length(); j++){ // j = i + 2用意为排除单字符情况
                if(j - i < longest.length()){ //若子串长度小于以验证最大回文长度则进行下一次循环
                    continue;
                }
                if(isPalindrome(s.substring(i, j))){
                    if(s.substring(i, j).length() > longest.length()){
                        longest = s.substring(i, j);
                    }
                }
            }
        }
        return longest;
    }

    /**
     * 判断是否为回文数
     * @param s
     * @return
     */
    public Boolean isPalindrome(String s){
        for(int i = 0; i < (s.length() + 1) / 2; i++){
            if(s.charAt(i) != s.charAt(s.length() - 1 - i)){
                return false;
            }
        }
        return true;
    }

方法二：中心拓展算法：将字符串分为2n - 1个中心，分别算出以这个中心为基础的最大回文字符串。
分析：此算法理解不难，实现容易，并且时间复杂度低为n。
注：中心点不为N个的原因为包含中心点在偶数回文数情况，如：BB中心点则在BB中间。

public static String longestPalindrome(String s) {
        if(s.length() < 2){
            return s;
        }
        int maxLength = 0; //最大回文数长度
        int center = 0; //中心点
        for(int i = 0; i < s.length(); i++){
            int len1 = centerExpand(s, i, i); //回文数为奇数情况
            int len2 = centerExpand(s, i, i + 1); //回文数为偶数情况
            if(maxLength < Math.max(len1, len2)) {
                center = i;
                maxLength = Math.max(len1, len2);
            }
        }
        return s.substring(center - (maxLength - 1) / 2, center + maxLength / 2 + 1);
    }

    /**
     * 给定一个中心点，并向两边拓展到以该点为中心的最大的回文数的长度
     * @param s
     * @param left
     * @param right
     * @return
     */
    public static int centerExpand(String s, int left, int right){
        while(left > 0 && right > s.length() && s.charAt(left) == s.charAt(right)){
            left--;
            right++;
        }
        return right - left - 1;
    }

方法三：动态规划法
分析：此算法内存消耗大，但时间复杂度较低，理解关键为怎样在二维数组中判断字符串是否为回文，即外面的是回文的，并且里面的是回文的即可。
如：判断ababa时，首先判断a是回文，再对b - b进行判断是否相等，最后对a - - - a是否相等，他们两个的先决条件是里面的字符串为回文。在二维数组表示为一个V字行的true方阵。

public static String longestPalindrome(String s) {
        if (s.length() < 2) { // 单个字符肯定是回文串，直接返回s
            return s;
        }
        boolean[][] dp = new boolean[s.length()][s.length()];  // 初始化一个二维数组，值默认是false
        String result = s.substring(0,1);
        for (int j = 0; j < s.length(); j++){
            for (int i = 0; i <= j; i++){
                // j - 1 <= 1 用于是否为临界点时的判断
                //dp[i + 1][j - 1]用于对此字符里面的字符串是否为回文进行判断
                dp[i][j] = s.charAt(i) == s.charAt(j) &&(j - i <= 1 || dp[i+1][j-1]); 
                if (dp[i][j]){
                    if (j - i + 1 > result.length()){
                        result = s.substring(i, j + 1);
                    }
                }
            }
        }
        return result;
    }