空栈异常答案

【问题标题】：Empty Stack Exception空栈异常
【发布时间】：2021-10-25 16:54:27
【问题描述】：

class Solution{
static boolean ispar(String x){
    char [] arr = x.toCharArray();
    int length = arr.length;
    Stack<Character> stack = new Stack<>();
    
    boolean isBalanced = true;
    if(arr[0] == '}' || arr[0] == ')' || arr[0] == ']'){
         isBalanced = false;
    }
    else{   
        for(int i=0; i<length; i++){
            char bracket = arr[i];
        
            if(bracket == '{' || bracket =='(' || bracket == '['){
                stack.push(bracket);
            }
            else if(!stack.empty() && 
                ((char) stack.peek() == '(' && (bracket == ')'))
                    || ((char) stack.peek() == '{' && bracket == '}')
                    || ((char) stack.peek() == '[' && bracket == ']')
                    ){
                stack.pop();
            }
            else{
            isBalanced = false;
            }
    }
    if(stack.empty()){
        isBalanced = true;            
   }
   else{
       isBalanced = false;
   }
 } 
 return isbalanced;
}
}

我正在学习Stack 数据结构。这是我要解决的第一个问题，但它给了我这个例外：

Exception in thread "main" java.util.EmptyStackException
at java.base/java.util.Stack.peek(Stack.java:102)
at Solution.ispar(File.java:57)
at Driverclass.main(File.java:23)

【问题讨论】：

我建议自己调试程序，它会更快更有用。这里有一篇很棒的文章：ericlippert.com/2014/03/05/how-to-debug-small-programs
问题在于您的else if 块，else if(!stack.empty() && ((char) stack.peek() == '(' && (bracket == ')') || ((char) stack.peek() == '{' && bracket == '}') || ((char) stack.peek() == '[' && bracket == ']'))) 需要这样更改，并且return isBalanced; 应该在最后return

标签： java data-structures

【解决方案1】：

这是在不更改核心尝试的情况下更正代码的尝试：

import java.util.Stack;

class Solution {
    public boolean isBalancedBrackets(String str) {
        char[] arr = str.toCharArray();
        Stack<Character> stack = new Stack<>();

        if (arr[0] == '}' || arr[0] == ')' || arr[0] == ']') {
            return false;
        } else {
            for (char bracket : arr) {
                if (bracket == '{' || bracket == '(' || bracket == '[') {
                    stack.push(bracket);
                } else if (!stack.empty() && 
                        (bracket == ')' && stack.peek() == '(' ||
                         bracket == '}' && stack.peek() == '{' ||
                         bracket == ']' && stack.peek() == '[')) {
                    stack.pop();
                } else {
                    return false;
                }
            }
        }

        return stack.empty();
    }
}

变化：

删除了多余的isBalanced变量，当您检测到不匹配时，您可以立即返回。
对于 else-if 语句，您需要使用一组括号将所有 or 条件组合在一起。这就是您获得EmptyStackException 的原因。因为如果堆栈不为空，您只想检查三个条件中的任何一个。
重命名方法。

另外，考虑使用Deque over a Stack in the future.

【讨论】：

实际上嵌套的 else-if 条件中有足够多的括号对，但是它们放错了位置。我认为如果您解释为什么需要将整组比较对放在一起以使 !stack.empty() 部分正常工作，您的回答会更有帮助。 :)
这提供了更多信息，IMO。干得好:)

【解决方案2】：

如果您想在@Sash Sinha 解决方案中省略字母，您可以添加一个新字段：

private static Set<Character> bracketSet = Set.of('(', ')', '{', '}', '[', ']');

以及方法：

public static boolean ommitLetters(Character chr) {
    return bracketSet.contains(chr);
}

在循环中实现它：

...

        for (char bracket : arr)
            if (ommitLetters(bracket)) {
                if (bracket == '{' || bracket == '(' || bracket == '[') {
                    stack.push(bracket);
                } else if (!stack.empty() && (bracket == ')' && stack.peek() == '('
                        || bracket == '}' && stack.peek() == '{' || bracket == ']' && stack.peek() == '[')) {
                    stack.pop();
                } else {
                    return false;
                }
            } else
                continue;

 ...

【讨论】：

+1 这样做的逻辑扩展是研究使用 HashMap，这将完全消除对 or 语句的要求。

【解决方案3】：

@ Sash Sinha - 是的，使用 HashMap 完全消除了对多或语句的要求，例如：

public static <K, V> K getKeyFromMapByValue(Map<K, V> map, V value) {
    for (Entry<K, V> entry : map.entrySet())
        if (entry.getValue().equals(value))
            return entry.getKey();
    return null;
}

private static Set<Character> validParenthesisSet = Set.of('(', ')', '{', '}', '[', ']');

public static boolean areParenthesisPaired(String expression) {
    Stack<Character> stack = new Stack<>();
    Map<Character, Character> parenthesisPairs = new HashMap<>() {
        private static final long serialVersionUID = 6725243592654448763L;
        {
            put('(', ')');
            put('{', '}');
            put('[', ']');
        }
    };

    for (Character actualParenthesis : expression.toCharArray()) {

        if (validParenthesisSet.contains(actualParenthesis))

            if (parenthesisPairs.containsValue(actualParenthesis)) { // must catch only closed
                Character oppositeParenthesis = getKeyFromMapByValue(parenthesisPairs, actualParenthesis);

                if (stack.size() == 0 || stack.peek() != oppositeParenthesis)
                    return false;

                stack.pop();

            } else
                stack.push(actualParenthesis);
    }

    if (stack.size() > 0)
        return false;

    return true;
}

【讨论】：