Java 检查括号是否匹配总是说它们匹配
我正在编写一个程序，在这个程序中，我应该检查左括号和右括号是否匹配。如果不匹配，我应该显示No。否则，我应该显示yes 这是我编写的函数，从输入缓冲区获取输入。然而，对于第二个测试用例，我只是不断地收到yes，而不是yes-NO-yes，但是其他两个用例是正确的Java 检查括号是否匹配总是说它们匹配,java,Java,我正在编写一个程序，在这个程序中，我应该检查左括号和右括号是否匹配。如果不匹配，我应该显示No。否则，我应该显示yes 这是我编写的函数，从输入缓冲区获取输入。然而，对于第二个测试用例，我只是不断地收到yes，而不是yes-NO-yes，但是其他两个用例是正确的 static String[] braces(String[] values) { Stack<Character> st = new Stack<Character>(); String[] answer =
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;
静态字符串[]大括号（字符串[]值）{
Stack st=新堆栈（）；
String[]answer=新字符串[values.length]；
对于（int i=0；i将stack.firstElement（）
更改为stack.peek（）
，您需要堆栈顶部而不是第一个元素。（firstElement
不是堆栈
方法）StackOverflow的最大秘密在于，实际上并不是所有的专家都像Neo看待矩阵一样看待代码，而是人们在检查你的程序如何运行
您可以自己完成这项工作，最古老、最琐碎的方法是通过所谓的“打印调试”
简而言之，您只需添加打印语句，打印您的代码正在执行的操作，然后将其与您认为应该执行的操作进行比较。以下是添加了此类打印语句的代码：
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);
}
}
嗯，看起来你在覆盖你以前的答案。你应该确保最后的测试不会覆盖循环的结论
简单的方法是检查answer[i]
是否为null，但更好的方法是创建第二个助手方法boolean brates（String）
，该方法可以在任何时候自由返回true
或false
，然后在brates（String[]）中的循环中调用该函数
无论如何，这将是我的实现：
import java.util.Stack;
class Test {
static char flip(char c) {
switch(c) {
case '}': return '{';
case ')': return '(';
case ']': return '[';
default: throw new IllegalArgumentException("Invalid paren " + c);
}
}
static boolean matched(String value) {
Stack<Character> st = new Stack<Character>();
for (int i=0; i<value.length(); i++) {
char c = value.charAt(i);
switch(c) {
case '{':
case '(':
case '[':
st.push(c);
break;
case '}':
case ')':
case ']':
if (st.isEmpty() || st.peek() != flip(c)) {
return false;
}
st.pop();
break;
}
}
return st.isEmpty();
}
static String[] braces(String[] values) {
String[] result = new String[values.length];
for(int i=0; i<result.length; i++) {
result[i] = matched(values[i]) ? "yes" : "no";
}
return result;
}
public static void main(String[] args) {
String[] input = new String[] { "}", "{}", "{()}", "asdf", "", "{[", "{[[([])]]}", "((foo))" };
String[] actual = braces(input);
String[] expected = new String[] { "no", "yes", "yes", "yes", "yes", "no", "yes", "yes" };
for(int i=0; i<actual.length; i++) {
if(!actual[i].equals(expected[i])) {
System.out.println("Failed: " + input[i] + " should have been " + expected[i]);
System.exit(1);
}
}
System.out.println("OK");
}
}
import java.util.Stack；
课堂测试{
静态字符翻转（字符c）{
开关（c）{
大小写“}”：返回“{”；
大小写“）”：返回“（”；
案例']'：返回'['；
默认值：抛出新的IllegalArgumentException（“无效参数”+c）；
}
}
静态布尔匹配（字符串值）{
Stack st=新堆栈（）；
对于（inti=0；iimportjava.util.*；
导入java.util.stream.collector；
公开课考试{
静态最终映射参数；
静态最终设定关闭参数；
静止的{
PARENS=新的HashMap（）；
PARENS.put（'{'，'}'）；
PARENS.put（'['，']'）；
PARENS.put（“（”，“）”）；
CLOSING_PARENS=新哈希集（PARENS.values（））；
}
公共静态void main（字符串[]args）{
打印（大括号（“（foo}”、“[]”、“（）”、“{}”、“[{}]”、“（[{}]）、“[[]]”）；
打印（大括号（“[”，“]”，“][”，“[{]}”）；
//测试用例2。。。
打印（大括号（“{[（）]}”，“{[（]）}”，“{{{[（（））]]}”）；
//…打印是否是。。。
}
静态无效打印（字符串…值）{
for（字符串str:values）{
系统输出打印（str+“”）；
}
System.out.println（）；
}
静态字符串[]大括号（字符串…值）{
返回Arrays.stream（值）
.map（测试：：isBalanced）
.map（b->b？“是”：“否”）
.collect（Collectors.toList（））.toArray（新字符串[values.length]）；
}
静态布尔isBalanced（字符串标记）{
堆栈=新堆栈（）；
for（char c:token.toCharArray（））{
if（PARENS.keySet（）包含（c））{
堆栈推送（c）；
}else if（结束部分包含（c））{
if（stack.isEmpty（）| |！PARENS.get（stack.pop（））.equals（c））{
返回false；
}
}
}
返回stack.isEmpty（）；
}
}
您只需进行以下更改
在所有情况下，将firstElement（）
替换为peek（）
从前两个案例中删除以下语句
stack.pop();
break;
检查最后一个案例中的堆栈是否为empity
如果（！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 = { "{}[](){[}]","{[()]}{[(])}{{[[(())]]}}","", "}][}}(}][))][](){()}()({}([][]))[](){)[](}]}]}))}(())(([[)"};
输出：
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 = { "{}[](){[}]","{[()]}{[(])}{{[[(())]]}}","", "}][}}(}][))][](){()}()({}([][]))[](){)[](}]}]}))}(())(([[)"};
[是，是，是，否]静态字符串[]大括号（字符串[]值）{
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;
}
Stack st=新堆栈（）；
String[]answer=新字符串[values.length]；
布尔值isCorrect=false；
for（int i=0；i
您试过调试它吗？寻求调试帮助的问题（“为什么此代码不工作？”）必须包括所需的行为、特定的问题或错误以及在问题中重现它所需的最短代码