Java 最长回文程序

我正在经历这个过程：

公共静态字符串最长回文（字符串s）{
如果（s==null | | s.length（）这是一种动态程序方法。从一个字母字符串（默认为回文）开始，逐渐增加字符串中的字母数

因为他们使用的是二维数组

    /*
 *      B  A  N  A  N  A
 *     ------------------
 *  B | T  F  F  F  F  F
 *  A |    T  F  T  F  T
 *  N |       T  F  T  F
 *  A |          T  F  T 
 *  N |             T  F
 *  A |                T
 * */

因此，空间复杂度n^2

对于任何[i][j]单元格，您需要检查[i+1][j-1]单元格，以确定添加此字母之前的子字符串是否为回文

下面的链接有一个非常清晰的视频，它正在使用类似的方法。

使用Javascript查找字符串中最长的回文
最优解
输出
在Leetcode上尝试这些解决方案：
“程序的哪一部分表明了这种空间复杂性。”-好吧，因为它说的是空间复杂性，所以可能是
新的布尔[len][len]
，即
n*n
元素的2D数组。此外，由于有两个嵌套循环在相同的
n
上运行（字符串长度）至少还有一个
O（n^2）
时间复杂度。我相信O（n^2）是因为嵌套迭代空间复杂度是O（n^2），因为程序需要字符串平方对象的长度来计算“new boolean[len][len]；”。它的时间复杂度也是O（n^2）因为有两个嵌套的for循环，其中第一个循环遍历字符串的长度，第二个循环遍历长度-k或平均长度/2。时间复杂度约为n*（n/2），但O表示法只关心复杂度中的最高值，即O（n^2）我没有过多考虑这个问题，但在我看来，代码的复杂性是双n循环->n^2。它如何寻找最长的回文？它创建了一个布尔值表，表中的每个元素表示（i，j）子字符串仍然是回文。最长回文是找到的i-j差异最大的回文。感谢视频链接。我不清楚最后一部分，如何确认
ANANA
在视频中是回文。因为在那个特定点
i=1
和
j=5
所以数组元素将是p[2][4]，在这个位置没有条目。你能解释一下它的那部分吗。在这里，我们可以说（1,4）代表子字符串“ANAN”。i代表起始字母（垂直方向为“A”），j代表结束字母（水平方向为“N”）.我们沿着对角线遍历。首先，我们取两个字母的子串，然后是3，然后是4，然后是5。因此，当你到达（1,5）时，前面的for循环将覆盖[（0,1），（1,4），（2,5）]，之前的for循环将覆盖[（0,2），（1,3），（2,4），（3,5）]，因此当你到达（1,5）时，（2,4）就准备好了.我希望我能解释一下。非常感谢，现在一切都清楚了。感谢分享这段精彩的视频。
    /*
 *      B  A  N  A  N  A
 *     ------------------
 *  B | T  F  F  F  F  F
 *  A |    T  F  T  F  T
 *  N |       T  F  T  F
 *  A |          T  F  T 
 *  N |             T  F
 *  A |                T
 * */

const lpal = str => {
  let lpal = ""; // to store longest palindrome encountered
  let pal = ""; // to store new palindromes found
  let left; // to iterate through left side indices of the character considered to be center of palindrome
  let right; // to iterate through left side indices of the character considered to be center of palindrome
  let j; // to iterate through all characters and considering each to be center of palindrome
  for (let i=0; i<str.length; i++) { // run through all characters considering them center of palindrome
    pal = str[i]; // initializing current palindrome
    j = i; // setting j as index at the center of palindorme
    left = j-1; // taking left index of j
    right = j+1; // taking right index of j
    while (str[j] === str[right]) { // while right elementis same as center element
      pal = pal + str[right]; // then add right to pal
      right++; // increase right by one
    }
    while (left >= 0 && right < str.length) { // while left and right indices exist
      if(str[left] === str[right]) { // if left value is equal to right value
        pal = str[left] + pal + str[right]; // add in front and back of pal
      } else { // if left value is NOT equal to right value
        break; // break out of while
      }
      left--; // move left index by one
      right++; // move right index by one
    }
    if(pal.length > lpal.length) { // if this pal longer than longest pal 
      lpal = pal; // set longest pal to be this pal
    }
  }
  return lpal; // return longest pal
}

const longestPalindrome = str => {
  let isPalindrome = false;
  let test;
  for (let i = str.length; i > 0; i--) {
    for (let j = 0; j <= str.length - i; j++) {
      isPalindrome = true;
      test = str.slice(j, j+i);
      for (let k = 0; k < Math.floor(test.length/2); k++) {
        if (test[k] !== test[test.length-1-k]) {
          isPalindrome = false;
          break;
        }
      }
      if (isPalindrome) {
        return test;
      }
    }
  }
  return "";
}

const longestPalindrome1 = str => {
  let longestPalindrome = "";
  for (let i = 0; i < str.length; i++) {
    for (let j = str.length ; j > i; j--) {
      const test = str.slice(i,j);
      let isPalindrome = true;
      for (let k = 0; k < test.length/2; k++) {
        if (test[k] !== test[test.length - 1 - k]) {
          isPalindrome = false;
        }
      }
      if (isPalindrome && test.length > longestPalindrome.length) {
        longestPalindrome = test;
        break;
      }
    }
  }
  return longestPalindrome;
}

const longestPalindrome2 = str => {
  if (str.length > 1){
    let [palindrome1, palindrome2] = [str, str];
    for (let i=0;i<Math.floor(str.length/2);i++) {
      if(str[i]!==str[str.length-i-1]) {
        palindrome1 = longestPalindrome(str.slice(0, str.length-1));
        palindrome2 = longestPalindrome(str.slice(1, str.length));
        break;
      }
    }
    return palindrome2.length > palindrome1.length ? palindrome2 : palindrome1;
  } else {
    return str;
  }
}

console.log(longestPalindrome2("babababababababababababa"));
console.log(longestPalindrome1("babababababababababababa"));
console.log(longestPalindrome("babababababababababababa"));
console.log(lpal("babababababababababababa"));

bababababababababababab
bababababababababababab
bababababababababababab
bababababababababababab