Question

我想检查String是否有匹配的大括号，括号或括号。

For example:
{}
()
[]

我可以用堆栈来做。我想用递归来做。我正在阅读类似问题的答案，回复是与堆栈混合的递归。用户回复了这些答案，说递归也是一个堆栈，所以你的递归方法不应该在参数中有一个堆栈 - 这对我来说很有意义。

我有一个很大的问题，我正在向后查看字符串并始终删除我检查的最后一个位置，直到String为空，所以我返回true。我无法想象我将如何检查特定的零件，大括号，括号或括号，而我的方法中没有额外的参数来保存我正在寻找的东西。但我一直认为必须有一种更简单的方法来做到这一点。

public boolean isBalanced(String in)
{
    if(in.isEmpty())
        return true;

    if(in.charAt(in.length()) == '}')
    {
        return recIsBalanced(in.substring(0, in.length()));
    }

    else if(in.charAt(in.length()) == ']')
    {

    }


    return recIsBalanced(in.substring(0, in.length()));
}

Answer 1

使用递归解决此问题的最简单方法是从两个方向收缩字符串。你从左边和右边迭代，直到你看到。如果这些不匹配，则String不平衡，否则对这些大括号之间的String应用相同的算法。只从一端走，将会更加棘手，你必须存储一些状态。

编辑：感谢DanielFischer。实际上从一侧迭代，例如离开，直到你找到一个大括号（如果这个大括号没有打开一个回归false）。然后从另一侧（在这种情况下右侧）迭代，直到找到匹配的括号。现在，当且仅当此大括号中包含的子字符串平衡和时，字符串才会平衡。右括号右侧的字符串均使用递归进行平衡。

Answer 2

 public static boolean isBalanced(String str) {

    if (str.length() == 0) {
        return true;
    }
    if (str.contains("()")) {
        return isBalanced(str.replaceFirst("\\(\\)", ""));
    }

    if (str.contains("[]")) {
        return isBalanced(str.replaceFirst("\\[\\]", ""));
    }

    if (str.contains("{}")) {
        return isBalanced(str.replaceFirst("\\{\\}", ""));
    } else {
        return false;
    }
}

Answer 3

这是一个解决方案，而不是替换任何东西，直接递归：

/**
 * @param args
 */
public  boolean balance(String s, int start, int end)
{
   System.out.println("start:"+start + " end" + end);
   if (start == s.length()) return end == 0;
   if (end<0) return false;
   //if (end == s.length()-1) return start == 0;
   if (s.charAt(start) == '(')
     return balance(s, start+1, end+1);
   if (s.charAt(start) == ')')
     return balance(s, start+1, end-1);
   return balance(s, start+1, end );

}

Answer 4

可以通过解析输入字符串来完成。这种情况的语法是：

P -> (P)
P -> [P]
P -> {P}
P -> e  (Null)

跟踪字符串中解析的位置更容易，并且递归堆栈包含要关闭的括号。这是简单的python实现。

ps = { '{': '}', '(': ')', '[': ']'}
all_ps = set(['{', '}', '(', ')', '[', ']'])
read_position = 0

def _is_balanced( s, closing_par=None ):
  global read_position
  while read_position < len(s):
    if s[read_position] == closing_par:
      read_position += 1         # Read closing parenthesis
      return True
    elif s[read_position] in ps:
      read_position += 1         # Read opening parenthesis
      if not _is_balanced( s, ps[s[read_position-1]] ):
        return False
    else:
      if s[read_position] not in all_ps:
        read_position += 1       # Read non-parenthesis char
      else:
        return False            # It is closing parenthesis, witouh opening before
  return closing_par is None    # Are we looking for a closing parenthesis?

def is_balanced( s ):
  global read_position
  read_position = 0  # Reset parsing position
  return _is_balanced( s )

Answer 5

boolean isBalanced(String str)
{
    if (str.isEmpty()) {
        return true;
    }
    else if (str.charAt(0) == '(') {
        return str.charAt(str.length() - 1) == ')'
            && isBalanced(str.substring(1, str.length()));
    }
    else if (str.charAt(0) == '[') {
        return str.charAt(str.length() -  1) == ']'
            && isBalanced(str.substring(1, str.length()));
    }
    else if (str.charAt(0) == '{') {
        return str.charAt(str.length() - 1) == '}'
            && isBalanced(str.substring(1, str.length()));
    }
    else {
        return true;
    }

}

递归检查String是否平衡

5 个答案: