通过递归确定嵌套括号（JAVA）

我试图编写一个方法来确定字符串中嵌套的括号对。 示例： “（（））”是真的 “（（4））”是假的 “（）”是假的 “（（））”是假的

public static boolean nestedBrackets(String s){
if(s.length()<4){
return false;
}
  else if(s.charAt(0) == '('&&s.charAt(s.length()-1)== ')'){

    if(s.charAt(1)=='('&&s.charAt(s.length()-2)==')'&&s.length()==4){
        return true;
    }
        else if(s.charAt(2)=='(' && s.charAt(s.length()-3)==')'&&s.length()==6){
        return true;
        }

    else {
      return false;
    }
  }  
  else {
     return false;

公共静态布尔嵌套方括号（字符串s）{
如果（s.length（）要递归地执行此操作，我们需要考虑归纳法。因此，我的基本情况是：

没有返回true的paren
一个非成对的paren left，返回false
我的归纳步骤是：

从左边开始，找到第一个（如果我找到a），然后返回false

从右边开始，找到第一个）如果我找到一个（返回false

如果我从左边找到一个，从右边找到一个，然后将字符串收缩到它们之间的子字符串并递归

因此，伪代码看起来像：

 Public Boolean ParenFinder(String testString){
     int left = 0;
     int right = 0;
     for (int i = 0; i < testString.length(); i++){
         if (testString.charAt(i) == '('){
                left = i;
                break;
         }
         if (testString.charAt(i) == ')'){
               return false;
         }
     }
     for (int i = testString.length(); i > 0; i--){
         if (testString.charAt(i) == ')'){
                right = i;
                break;
         }
         if (testString.charAt(i) == '('){
               return false;
         }
     }

     if (left == 0 && right == 0 && testString.charAt(0) != '(')
                  return true;
     return (ParenFinder(testString.subString(left, right));              
 }

Public Boolean ParenFinder（String testString）{
int左=0；
int right=0；
对于（int i=0；i0；i--）{
if（testString.charAt（i）=='）'）{
右=i；
打破
}
if（testString.charAt（i）='（'）{
返回false；
}
}
if（left==0&&right==0&&testString.charAt（0）！='（'）
返回true；
返回（ParenFinder（testString.subString（左、右））；
}
由于您的问题被标记为“递归”，因此提供了递归解决方案

public static boolean nestedBrackets(String s)
{
    if (s.length() < 2)
    {
        return false;
    }
    if (s.charAt(0) != '(')
    {
        return false;
    }
    if (s.charAt(s.length() - 1) != ')')
    {
        return false;
    }
    if (s.length() == 2)
    {
        return true;
    }
    return nestedBrackets(s.substring(1, s.length() - 1));
}

公共静态布尔嵌套方括号（字符串s）
{
如果（s.长度（）<2）
{
返回false；
}
如果（s.charAt（0）！='（'）
{
返回false；
}
如果（s.charAt（s.length（）-1）！='）'）
{
返回false；
}
如果（s.长度（）==2）
{
返回true；
}
返回嵌套方括号（s.substring（1，s.length（）-1））；
}

实现很简单。每次递归时，确保整个表达式都在括号内，然后对括号内的内容进行递归。对于一对括号，达到了终止条件：“（）”

注意：您没有提到空字符串大小写（“”）的预期结果。下面提供的上述解决方案返回空字符串的
false
。
您当前的实现有什么问题？@EricJ。它对（（（））失败条件，因为它返回true。OP，嵌套parens的规则是什么？原始字符串是否只包含parens？这需要使用堆栈。还需要一个计数器来知道嵌套级别。您忘了写这个问题。@MarshallTigerus要使布尔值为true，它只能包含parens，并且必须嵌套。但在测试时，字符串可能包含字母或数字等@user3513461您可能需要根据具体规则对其进行调整