Question

我正在编写一个程序，在其中应检查左括号是否与右括号匹配。如果不匹配，则应显示“否”。否则，应显示“是”。

这是我编写的函数，从输入缓冲区获取输入。但是，我只是继续在第二个测试用例中收到“是”，而不是“是否是”，但其他两个情况都是正确的。

static String[] braces(String[] values) {
Stack<Character> st = new Stack<Character>();
String[] answer = new String[values.length];
for(int i =0; i<values.length;i++){
  char[] crt = values[i].toCharArray();
  for(char c : crt){
    switch(c){
      case '{':
      case '(':
      case '[':
        st.push(c);
        break;
      case '}':
        if(st.isEmpty() || (st.peek() != '{'))
        {
          answer[i]= "NO";
            break;
        }
        st.pop();

      case ')':
        if(st.isEmpty() || (st.peek() != '('))
        {
          answer[i]= "NO";
            break;
        }
        st.pop();


      case ']':
        if(st.isEmpty() || (st.peek() != '['))
        {
          answer[i]= "NO";
            break;
        }
        st.pop();


    }
  }


  if(st.isEmpty() && answer[i].equals("NO") ){
    answer[i]="YES";
    System.out.println("I set answer[" + i + "] = YES due to stack being empty");
  }
  else
  {
    answer[i]="NO";
    System.out.println("I set answer[" + i + "] = NO due to stack being non-empty");
  }
          st.clear();
}
return answer;

}

Answer 1

将stack.firstElement()更改为stack.peek()，您需要堆栈顶部而不是第一个元素。（firstElement不是Stack方法）

Answer 2

StackOverflow的一个伟大秘密是，实际上，像Neo对待Matrix一样，查看代码的专家并不多。只是人们在检查您的程序如何运行。

您可以自己执行此操作，最古老，最简单的方法是通过所谓的“打印调试”。

简而言之，您只需要添加打印语句来打印您的代码在做什么，然后继续进行比较，并将其与您认为它在做什么进行比较。这是添加了此类打印语句的代码：

import java.util.*;

public class Test {
  static String[] braces(String[] values) {
    Stack<Character> st = new Stack<Character>();
    String[] answer = new String[values.length];
    for(int i =0; i<values.length;i++){
      char[] crt = values[i].toCharArray();
      boolean an = false;
      for(char c : crt){
        switch(c){
          case '{':
          case '(':
          case '[':
            st.push(c);
            break;
          case '}':
            if(st.isEmpty() || (st.firstElement() != '{'))
            {
              answer[i]= "NO";
              System.out.println("I set answer[" + i + "] = NO due to mismatched }");
            }
            st.pop();
            break;

          case ')':
            if(st.isEmpty() || (st.firstElement() != '('))
            {
              answer[i]= "NO";
              System.out.println("I set answer[" + i + "] = NO due to mismatched )");
            }
            st.pop();
            break;

          case ']':
            if(st.isEmpty() || (st.firstElement() != '['))
            {
              answer[i]= "NO";
              System.out.println("I set answer[" + i + "] = NO due to mismatched ]");
            }
            st.pop();
            break;

        }
      }

      if(st.isEmpty()){
        answer[i]="yes";
        System.out.println("I set answer[" + i + "] = YES due to stack being empty");
      }
      else
      {
        answer[i]="no";
        System.out.println("I set answer[" + i + "] = NO due to stack being non-empty");
      }
      st.clear();
    }

    return answer;
  }
  public static void main(String[] args) {
    String[] result = braces(new String[] { "(foo}" });
    for(String s : result) System.out.println("The final result is " + s);
  }
}

这是在字符串(foo}上运行的输出：

I set answer[0] = NO due to mismatched }
I set answer[0] = YES due to stack being empty
The final result is yes

欢迎，看来您正在覆盖以前的答案。您应该确保最终测试不会覆盖循环的结论。

最简单的方法是检查answer[i]是否为空，但是更好的方法是创建第二个辅助方法boolean braces(String)，该方法对return true或{{1}是免费的}，然后在false

中循环调用该函数

无论如何，这将是我的实现：

braces(String[])

Answer 3

import java.util.*;
import java.util.stream.Collectors;

public class Test {

    static final Map<Character, Character> PARENS;
    static final Set<Character> CLOSING_PARENS;
    static {
        PARENS = new HashMap<>();
        PARENS.put('{', '}');
        PARENS.put('[', ']');
        PARENS.put('(', ')');
        CLOSING_PARENS = new HashSet<>(PARENS.values());
    }

    public static void main(String[] args) {

        print(braces("(foo}","[]","()","{}","[{}]","([{}])","[[]]"));
        print(braces("[","]","][","[{]}"));

        // test case 2 ...

        print(braces("{[()]}","{[(])}","{{[[(())]]}}"));

        // ... prints YES NO YES  ...
    }

    static void print(String ... values){
        for(String str : values){
            System.out.print(str + " ");
        }
        System.out.println();
    }

    static String [] braces(String ... values) {
        return Arrays.stream(values)
                .map(Test::isBalanced)
                .map(b -> b ? "YES" : "NO")
                .collect(Collectors.toList()).toArray(new String[values.length]);
    }

    static boolean isBalanced(String token){

        Stack<Character> stack = new Stack<>();
        for(char c : token.toCharArray()){

            if (PARENS.keySet().contains(c)){

                stack.push(c);

            } else if(CLOSING_PARENS.contains(c)){

                if(stack.isEmpty() || !PARENS.get(stack.pop()).equals(c)) {
                    return false;
                }
            }
        }

        return stack.isEmpty();

    }

}

Answer 4

您只需要进行以下更改

在所有情况下都将firstElement()替换为peek()
从前两个案例中删除以下声明
```
      stack.pop();
      break;
```
1. 在最后一种情况下检查堆栈是否为空
if（！stack.isEmpty（））

更正的代码：

public class ParenMatch{

    public static void main(String[] args){
    String[] str = { "{}[](){[}]","{[()]}{[(])}{{[[(())]]}}","", "}][}}(}][))][](){()}()({}([][]))[](){)[](}]}]}))}(())(([[)"}; 
    System.out.println(Arrays.toString(braces(str)));
    }

public static String[] braces(String[] values)
{
    Stack<Character> stack = new Stack<Character>();
    String[] isCorrect = new String[values.length];
    for (int i = 0; i < values.length; i++)
    {
        char[] crt = values[i].toCharArray();
        boolean an = false;
        for (char c : crt)
        {
            switch(c)
            {
                case '{':
                case '(':
                case '[':
                    stack.push(c);
                    break;
                case '}':
                    if (stack.isEmpty() || (stack.peek() != '{'))
                    {
                        isCorrect[i] = "NO";
                    }
                    //stack.pop();
                    //break;

                case ')':
                    if (stack.isEmpty() || (stack.peek() != '('))
                    {
                        isCorrect[i] = "NO";
                    }
                    //stack.pop();
                    //break;

                case ']':
                    if (stack.isEmpty() || (stack.peek() != '['))
                    {
                        isCorrect[i] = "NO";
                    }
                    if(!stack.isEmpty())
                    stack.pop();
                    break;
            }
        }
        if (stack.isEmpty())
        {
            isCorrect[i] = "yes";
        }
        else
        {
            isCorrect[i] = "no";
        }
        stack.clear();
    }

    return isCorrect;
}
}

输入：

String[] str = { "{}[](){[}]","{[()]}{[(])}{{[[(())]]}}","", "}][}}(}][))][](){()}()({}([][]))[](){)[](}]}]}))}(())(([[)"};

输出：

[是，是，是，否]

Answer 5

static String[] braces(String[] values) {
    Stack<Character> st = new Stack<Character>();
     String []answer = new String[values.length];
     Boolean isCorrect = false;

    for(int i =0; i< values.length;i++)
     {
         isCorrect = true;
        st.clear();
         char crt[] = values[i].toCharArray();

        for(char c : crt)
         { 
             switch(c)
             {
             case'{':
             case'[':
             case'(':
                 st.push(c);
                 break;

                 case'}':
                 if(st.isEmpty() || st.peek() != '{')
                 {
                     System.out.println("Hellooo");
                     answer[i] ="NO";
                     isCorrect = false;
                 }
                 if(!st.isEmpty()) 
                 {
                    st.pop();
                 }
                 break;

                 case']':
                 if(st.isEmpty() || st.peek() != '[')
                 { 
                     System.out.println("Hell");
                     answer[i] ="NO";
                     isCorrect = false;
                 }
                 if(!st.isEmpty()) 
                 {
                     st.pop();
                }

                 break;

                case')':
                 if(st.isEmpty() || st.peek() != '(')
                 {
                     isCorrect = false;
                 }

                 if(!st.isEmpty()) {

                     st.pop();

                     }

                 break;
             }
         }

         if(isCorrect && st.isEmpty())

         {
             answer[i] = "YES";
             System.out.println("Hello");
         }else answer[i] = "NO";
     }
    return answer;
}

在检查括号是否匹配时，总是会说它们匹配

5 个答案: