最长（大）回文串的查找（字符串中找出最长的回文串）PHP实现

Posted 2021-02-14 翩翩叶随风

首先还是先解释一下什么是回文串：就是从左到右或者从右到左读，都是同样的字符串。比如：上海自来水来自海上，bob等等。

那么什么又是找出最长回文串呢？

例如：字符串abcdefedcfggggggfc，其中efe,defed,cdefedc,gg,ggg,gggg,ggggg,gggggg,fggggggf,cfggggggfc都是回文串，左右完全一样。

这其中，有最短的gg，最长的cfggggggfc，还有其他长度的。忽略长度为1的。毕竟一个字符的都算回文了。

那么，找出最长的，就是找出这个cfggggggfc。

说实话，最开始想到的办法，就是暴力的枚举，也就是找出原字符串的所有子串，然后逐一判断是否是回文串，如果是就记录下来该字符串。

然后，碰到下一个回文串的时候，再对比两个字符串的长度，谁长，就把谁记录下来。

感觉遍历、枚举这类操作真的是万能的。。。

 

先来段暴力的代码，定个场。

通过两层循环，逐一筛选字符串的子串，找出所有回文串，并不断判断，记录最长的回文串

 1 function is_palindrome($str)
 2 {
 3     $strrev = strrev($str);// 逆序字符串
 4     return $strrev == $str ? 1 : 0;
 5 }
 6 
 7 function get_max_palindrome($str)
 8 {
 9     $len = strlen($str);
10     $res = ‘‘;// 结果
11     for ($i = 0; $i < $len - 2; $i++) {// $i 用于定义字符串起始位置，倒数第二个和最后一个如果还不能组成回文串，最后一个就不需要截取了
12         for ($j = $i + 2; $j <= $len; $j++) {// $j 用于逐一延长子字符串的长度，（$j=$i+2）截取子串长度2位起，所以循环条件使用的是<=不是<
13             $tmp = substr($str, $i, $j - $i);// 逐一截取子串
14             if (is_palindrome($tmp)) {// 判断当前截取的子串是否是回文串
15                 if (strlen($tmp) > strlen($res)) {// 是回文串，则再判断是否长度大于结果中保存的回文串
16                     $res = $tmp;// 当前回文串大于结果中的，将结果变量更新成当前的回文串
17                 }
18             }
19         }
20     }
21     return $res;
22 }
23 
24 $str = "abcdefedcfggggggfc";
25 echo get_max_palindrome($str);

这方法感觉还不错，简单直观，并且代码也算简单。就是会被鄙视，毕竟这个太初级，太暴力。越简单粗暴不是越好么？

 

简单粗暴的有了，有没有可以装一下的？有没有什么好玩的？有没有......于是就有了下边的程序。

 1 function get_max_palindrome1($str)
 2 {
 3     $len = strlen($str);
 4     $res = [];// 结果数组
 5     $res2= [];// 偶数长度的结果
 6     // 使用array_unshift的目的是为了从前向数组插入每一次找到的答案。也可以直接更新单个元素数组，就是只要当前取到的字符串比原来的长，就把原来的覆盖掉
 7     // 使用多维数组不是必须的，以为数组或者变量也可以。这里就是做一个简单的记录，可以微调一下，多完成另一个功能
 8     array_unshift($res, $str[0]);// 默认将第一个字符作为最长回文串写入数组
 9     array_unshift($res2, ‘‘);// 默认一个空字符串，长度为0，初始化
10 
11     for ($i = 1; $i < $len - 1; $i++) {// 从第二个开始操作，因为第一个左边没有字符，只能算本身长度为1的回文串
12         // 针对奇数长度的最长回文串
13         $left = $right = $i;// 从中间向两边扩展，默认起始位置为中间的这个位置
14         $tmp = $str[$i];// 临时回文串，用于中间数据处理，默认是当前字符串
15         while ($left > 0 and $right < $len - 1) {// 限定，只要有任何一边到头，循环结束
16             $left--;// 左边向左扩展
17             $right++;// 右边向??扩展
18             if ($str[$left] == $str[$right]) {// 如果扩展以后左右相等，说明当前是回文串
19                 $tmp = $str[$left] . $tmp . $str[$right];// 将当前符合的回文串组合在一起
20                 if (strlen($tmp) > strlen($res[0])) {// 如果当前得到的回文串比原来数组中最长的回文串长，则记录该回文串信息
21                     array_unshift($res, $tmp);// 将当前回文串信息（长度和内容）记录在结果数组中
22                 }
23             } else {// 不相等，就不用处理后续了，跳出循环
24                 break;
25             }
26         }
27         // 针对偶数长度的最长回文串
28         $left2 = $i - 1;
29         $right2 = $i;// 从中间向两边扩展，默认起始位置为中间的这个位置
30         if ($str[$i] == $str[$i-1]) {// 如果当前的字符和他前一个字符相等，说明很可能是一个偶数长度的回文串
31             $tmp2 = $str[$i-1] . $str[$i];// 两个拼一起，记录下来作为初始字符串
32             if (count($res2) == 1) {// 如果只有一个，说明是只有一个默认的无效的元素
33                 array_unshift($res2, $tmp2);// 相当于真正有效的第一个偶数长度的字符串
34             }
35             while ($left2 > 0 and $right2 < $len - 1) {
36                 $left2--;
37                 $right2++;
38                 if ($str[$left2] == $str[$right2]) {// 如果扩展以后左右相等，说明当前是回文串
39                     $tmp2 = $str[$left2] . $tmp2 . $str[$right2];// 将当前符合的回文串组合在一起
40                     if (strlen($tmp2) > strlen($res2[0])) {// 如果当前得到的回文串比原来数组中最长的回文串长，则记录该回文串信息
41                         array_unshift($res2, $tmp2);// 将当前回文串信息（长度和内容）记录在结果数组中
42                     }
43                 } else {// 不相等，就不用处理后续了，跳出循环
44                     break;
45                 }
46             }
47         }
48     }
49     // 结果数组中，第一个元素就是str是最长的回文串，谁长就返回谁
50     if (strlen($res[0]) >= strlen($res2[0])) {
51         return $res[0];// 奇数长度回文数组
52     } else {
53         return $res2[0];// 偶数长度回文数组
54     }
55 }
56 
57 $str = "abcdefedcfggggggfc";
58 echo get_max_palindrome1($str);

这段代码厉害了，自己写完调试通了，自己都飒了一下！

看着就多吧？看这阵容，单单代码行数就比“简单粗暴”翻了三倍啊。是不是复杂粗暴？

虽然代码多了一些，但是也算好理解。

简单解释一下大致的思路，从第二个字符开始一直到倒数第二个，循环的假设他们是回文串的最中间的那个字符（左右根据它对称）

1、当前指针指向的字符串为假设的回文串的中心

2、将左右两个指针同时向两边相同步长的移动一下

3、对比左右两个指针指向的字符是否相同

4、如果相同，说明是回文串，然后将左右指针指向的值和两个值中间的值拼接到一起，生成回文串，并统计长度

5、生成新回文串的长度，和结果数组中最长回文串的长度对比，如果够长，则将当前回文串写入数组前边

直到左右指针向两边移动后，左右指针对应的字符不相同，则回文串结束，跳出回文串验证循环，将外层循环加1，将中心移到下一个，重复1-5步，完成下一组回文串的验证

直到中心移动到倒数第二个，完成比对后。最终数组第一个元素，就是最长的回文串。

当然，代码复杂，是因为还有一个情况要考虑，回文串分奇数长度回文串和偶数长度回文串例如：bob这个，o是中心，长度为3，奇数。

还有一种情况就是noon，这样中间可以看做是空字符串，也可以理解成两个oo，长度为4，偶数。

总之处理奇数长度回文串和偶数长度回文串稍微有一点区别，思路一样，代码很像，但是区别还是有的。

所以，这种通过不断移动回文串假设的中心的方法，看着挺有想法的，也算是很巧妙，但实际上稍微复杂啰嗦了一点，考虑的情况也多了一些。

 

按照常理，很难一下子就写出最终的代码，一般只要留心，仔细想想，都有可能有优化的空间，于是，上边的代码就变成了下边的代码了。

 1 function get_max_palindrome2($str)
 2 {
 3     $len = strlen($str);// 获取字符串的长度，用于右边界设定
 4     $res = $res2 =‘‘;// 初始化
 5     for ($i = 1; $i < $len - 1; $i++) {// 从第二个开始操作，因为第一个左边没有字符，只能算本身长度为1的回文串
 6         // 针对奇数长度的最长回文串
 7         $left = $right = $i;// 从中间向两边扩展，默认起始位置为中间的这个位置
 8         $tmp = $str[$i];// 临时回文串，用于中间数据处理，默认是当前字符串
 9         while ($left-- > 0 and $right++ < $len - 1) {// 限定，只要有任何一边到头，循环结束（$left--左边向左扩展，right++右边向右扩展）
10             if ($str[$left] != $str[$right])  break;// 不相等，不是回文串，就不用处理后续了，跳出循环
11             $tmp = $str[$left] . $tmp . $str[$right];// 将当前符合的回文串组合在一起
12             if (strlen($tmp) > strlen($res)) $res = $tmp;// 当前得到的回文串比原来的回文串长，记录当前回文串
13         }
14         // 针对偶数长度的最长回文串
15         $left2 = $i - 1;
16         $right2 = $i;// 从中间向两边扩展，默认起始位置为中间的这个位置
17         if ($str[$i] == $str[$i - 1]) {// 如果当前的字符和他前一个字符相等，说明是一个偶数长度的回文串
18             $tmp2 = $str[$i - 1] . $str[$i];// 两个拼一起，记录下来作为初始字符串
19             if (strlen($tmp2) > strlen($res2)) $res2 = $tmp2;// 如果当前得到的回文串比原来最长的回文串长，则记录该回文串信息
20             while ($left2-- > 0 and $right2++ < $len - 1) {
21                 if ($str[$left2] != $str[$right2]) break;// 不相等，不是回文串，就不用处理后续了，跳出循环
22                 $tmp2 = $str[$left2] . $tmp2 . $str[$right2];// 将当前符合的回文串组合在一起
23                 if (strlen($tmp2) > strlen($res2)) $res2 = $tmp2;// 如果当前得到的回文串比原来最长的回文串长，则记录该回文串信息
24             }
25         }
26     }
27     // 两个（奇数长度回文串和偶数长度回文串）结果中，谁长谁是最长的回文串
28     return strlen($res) >= strlen($res2) ? $res : $res2;
29 }
30 
31 $str = "abcdefedcfggggggfc";
32 echo get_max_palindrome2($str);

这个就看着简洁紧凑了吧？不止是代码减少了冗余，也换了个别地方的写法，同样可以节省代码量和空间的使用量。因为思路和实现方法与上一个一样，只是对代码做了个二次优化。

就不重复说明了，好在注释够详细。只说一点，正常情况下，没有人能保证第一次就写出最合适的代码，很有可能要优化一次以上，代码越多，逻辑越复杂，可以优化的空间就越大。

 

正常，代码写到这里，就算完事了，结束了。想做的都实现了。感觉上没什么了。但是，人外有人啊。不一定谁就有什么牛逼的思路呢。。。

这一百度，，，还真是，有一个牛人叫Manacher，在1975年，弄出个马拉车算法。真是有想法啊。很羡慕。

看了几篇文章的解释吧，说实话，打眼一看，都很专业，大篇幅，带表格，带图解，很高级的感觉。但是大部分都不好理解。所以，基本上一篇都没看完。

现在现忽略这个牛人的牛思路，毕竟他这个给每个字符两边包上特殊符号的办法，确实就已经是一个很新奇的思路了。只用这个方法，就会精简很多代码的。

毕竟，通过加入特殊符号，所有的回文串就不区分是偶数长度，还是奇数长度了，都统一按照奇数长度处理，最后将特殊符号过滤掉即可。

那么这个特殊符号是以什么形式加入原来的字符串中呢？例如：123321加入特殊符号“#”，结果是：#1#2#3#3#2#1#；121加入“#”号，结果是：#1#2#1#。

字符串这么处理以后，就都是奇数长度的回文串了。下面就根据这样的字符串写一个新的方法

 1 function get_max_palindrome_m($str)
 2 {
 3     $res = $str[0];
 4     // 用“#”包上字符串的每一个字符，比如abc转换成#a#b#c#。这样就导致不管是奇数长度的回文还是偶数长度的都是可以按照奇数的处理
 5     $str = ‘#‘ . implode(‘#‘, str_split($str)) . ‘#‘;
 6     $len = strlen($str);// 获取处理后字符串的长度
 7     for ($i = 2; $i < $len; $i++) {
 8         $left = $right = $i;
 9         while ($left > 0 and $right < $len - 2) {// 只要任意一边不到字符串的边际，就继续循环
10             if ($str[$i] == ‘#‘) {// 如果是#号，说明相邻的左右两个是正常的字符串，所以左右各扩展一位
11                  $left--;
12                  $right++;
13             } else {// 如果不是#号，说明相邻的两个字符都是#号，直接左右两边各扩展两位来取字符比较
14                 $left -= 2;
15                 $right += 2;
16             }
17             if ($str[$left] != $str[$right]) break;// 只要有一对不相等了，就跳出循环
18             $tmp = substr($str, $left, $right - $left + 1);// 左右两边同样步长的字符相等，则说明这区间是回文串，截取符合条件部分的字符串
19             if (strlen($tmp) > strlen($res)) {// 如果当前获取的回文串比记录的长，则更新结果数组
20                 $res = $tmp;
21             }
22         }
23     }
24     return str_replace(‘#‘, ‘‘, $res);
25 }
26 
27 $str = "abcdefedcfggggggfc";
28 echo get_max_palindrome_m($str);

这代码，明显看着简单清晰多了。看着也相对好理解了。因为只要理解一种情况就可以了。当然，为了减少一定的循环次数，while循环里多一个判断，如果没有这个判断，统一加1减1，代码会少很多行。

那么，以上这段代码就是根据网上的提示，加工原字符串，最终再一次优化了程序。代码精简了，思路也更简洁清晰了。那么可以想想，到这里，还可以再优化么？

 

毕竟上边的代码是有了新思路后的第一版的代码，仔细想想，还是可以精简的。

 1 function get_max_palindrome_m1($str)
 2 {
 3     $res = $str[0];
 4     $str = ‘#‘ . implode(‘#‘, str_split($str)) . ‘#‘;// “#”包上字符串的每一个字符，比如abc转换成#a#b#c#。奇数或偶数长度的回文串都可以按奇数长度处理
 5     $len = strlen($str);// 获取处理后字符串的长度
 6     for ($i = 2; $i < $len; $i++) {// 因为第一个字符是“#”属于没意义字符因此从第三个开始正常处理
 7         $step = 0;// 初始化步长
 8         while ($i - $step > 0 and $i + $step < $len - 2) {// 任意一边不到字符串的边际，继续循环（最后一位属于没意义字符因此处理到$len-2就算结尾）
 9             $str[$i] == ‘#‘ ? $step++ : $step += 2;// 当前字符是“#”，步长左右各扩展1位即可，否则扩展2位（因为1位是两个“#”没意义）
10             if ($str[$i - $step] != $str[$i + $step]) break;// 只要有一对不相等了，就跳出循环
11             $tmp = substr($str, ($i - $step), $step * 2 + 1);// $tmp = substr($str, ($i - $step), ($i + $step) - ($i - $step) + 1);
12             if (strlen($tmp) > strlen($res)) $res = $tmp;// 如果当前获取的回文串比记录的长，则更新结果数组
13         }
14     }
15     return str_replace(‘#‘, ‘‘, $res);
16 }
17 
18 $str = "abcdefedcfggggggfc";
19 echo get_max_palindrome_m1($str);

这样整理之后，是不是看着又简洁了很多？

程序都是不断优化改进的，随着掌握的技术，了解了新思路，熟能生巧的经验，代码都会越来越精简，越来越优化。

没有最好，只有更好！