Как проверить, сбалансирована ли строка?
Я хочу проверить, сбалансирована ли входная строка. Он будет сбалансирован, если есть соответствующие Открытие и закрытие скобки, скобки или скобки.
example:
{} balanced
() balanced
[] balanced
If S is balanced so is (S)
If S and T are balanced so is ST
public static boolean isBalanced(String in)
{
Stack st = new Stack();
for(char chr : in.toCharArray())
{
if(chr == '{')
st.push(chr);
}
return false;
}
У меня проблемы с выбором того, что делать. Должен ли я поместить каждую открывающую или закрывающую скобку, скобку или скобку в стек, а затем вытащить их? Если я их вытащу, как это мне поможет?
6 ответов
1) для каждой открывающей скобки: { [ ( толкать его в стек.
2) для каждой закрывающей скобки: } ] ) pop из стека и проверьте, соответствует ли тип кронштейна. Если не вернуться false;
то есть текущий символ в строке } и если выскочил из стека что-нибудь еще из возвращение false немедленно.
3) Если конец строки и стек не пуст, вернуть false, иначе true.
да, стек является подходящим выбором для задачи, или вы можете использовать рекурсивную функцию. Если вы используете стек, то идея заключается в том, что вы нажимаете каждую открывающую скобку в стеке, когда вы сталкиваетесь с закрывающей скобкой, вы проверяете, что верхняя часть стека соответствует ей. Если он соответствует, вытащите его, если нет, это ошибка. По завершении стек должен быть пуст.
import java.util.Stack;
public class Balanced {
public static boolean isBalanced(String in)
{
Stack<Character> st = new Stack<Character>();
for(char chr : in.toCharArray())
{
switch(chr) {
case '{':
case '(':
case '[':
st.push(chr);
break;
case ']':
if(st.isEmpty() || st.pop() != '[')
return false;
break;
case ')':
if(st.isEmpty() || st.pop() != '(')
return false;
break;
case '}':
if(st.isEmpty() || st.pop() != '{')
return false;
break;
}
}
return st.isEmpty();
}
public static void main(String args[]) {
if(args.length != 0) {
if(isBalanced(args[0]))
System.out.println(args[0] + " is balanced");
else
System.out.println(args[0] + " is not balanced");
}
}
}
ну, грубо говоря, если он сбалансирован, это означает, что ваш стек должен быть пустым.
для этого вам нужно поп ваш стек, когда вы разбираете }
дополнительное требование-проверить это } предшествует { или выскочил символ {.
ниже Java пример кода для определения сбалансированности строки.
http://introcs.cs.princeton.edu/java/43stack/Parentheses.java.html
идея в том, что -
- для каждой открывающей скобки
( [ {, нажмите его на стеке. - для закрывающей скобки
) ] }, попробуйте поп соответствующий открытие скобки( [ }из стека. Если вы не можете найти подходящую открывающую скобку, строка не сбалансирована. - если после обработки полной строки стек пуст, то строка сбалансирована. В противном случае строка не сбалансирована.
import java.util.Stack;
public class SyntaxChecker {
/**
* This enum represents all types of open brackets. If we have a new type then
* just add it to this list with the corresponding closed bracket in the other
* ClosedBracketTypes enum
* @author AnishBivalkar
*
*/
private enum OpenBracketTypes {
LEFT_ROUND_BRACKET('('),
LEFT_SQUARE_BRACKET('['),
LEFT_CURLY_BRACKET('{');
char ch;
// Constructs the given bracket type
OpenBracketTypes(char ch) {
this.ch = ch;
}
// Getter for the type of bracket
public final char getBracket() {
return ch;
}
/**
* This method checks if the current character is of type OpenBrackets
* @param name
* @return True if the current character is of type OpenBrackets, false otherwise
*/
public static boolean contains(final char name) {
for (OpenBracketTypes type : OpenBracketTypes.values()) {
if (type.getBracket() == name) {
return true;
}
}
return false;
}
}
/**
* This enum represents all types of Closed brackets. If we have a new type then
* just add it to this list with the corresponding open bracket in the other
* OpenBracketTypes enum
* @author AnishBivalkar
*
*/
private enum CloseBracketTypes {
RIGHT_ROUND_BRACKET(')'),
RIGHT_SQUARE_BRACKET(']'),
RIGHT_CURLY_BRACKET('}');
char ch;
CloseBracketTypes(char ch) {
this.ch = ch;
}
private char getBracket() {
return ch;
}
/**
* This method checks if a given bracket type is a closing bracket and if it correctly
* completes the opening bracket
* @param bracket
* @param brackets
* @return
*/
public static boolean isBracketMatching(char bracket, Stack<Character> brackets) {
// If the current stack is empty and we encountered a closing bracket then this is
// an incorrect syntax
if (brackets.isEmpty()) {
return false;
} else {
if (bracket == CloseBracketTypes.RIGHT_ROUND_BRACKET.getBracket()) {
if (brackets.peek() == OpenBracketTypes.LEFT_ROUND_BRACKET.getBracket()) {
return true;
}
} else if (bracket == CloseBracketTypes.RIGHT_SQUARE_BRACKET.ch) {
if (brackets.peek() == OpenBracketTypes.LEFT_SQUARE_BRACKET.getBracket()) {
return true;
}
} else if (bracket == CloseBracketTypes.RIGHT_CURLY_BRACKET.ch) {
if (brackets.peek() == OpenBracketTypes.LEFT_CURLY_BRACKET.getBracket()) {
return true;
}
}
return false;
}
}
/**
* This method checks if the current character is of type ClosedBrackets
* @param name
* @return true if the current character is of type ClosedBrackets, false otherwise
*/
public static boolean contains(final char name) {
for (CloseBracketTypes type : CloseBracketTypes.values()) {
if (type.getBracket() == name) {
return true;
}
}
return false;
}
}
/**
* This method check the syntax for brackets. There should always exist a
* corresponding closing bracket for a open bracket of same type.
*
* It runs in O(N) time with O(N) worst case space complexity for the stack
* @param sentence The string whose syntax is to be checked
* @return True if the syntax of the given string is correct, false otherwise
*/
public static boolean matchBrackets(String sentence) {
boolean bracketsMatched = true;
// Check if sentence is null
if (sentence == null) {
throw new IllegalArgumentException("Input cannot be null");
}
// Empty string has correct syntax
if (sentence.isEmpty()) {
return bracketsMatched;
} else {
Stack<Character> brackets = new Stack<Character>();
char[] letters = sentence.toCharArray();
for (char letter : letters) {
// If the letter is a type of open bracket then push it
// in stack else if the letter is a type of closing bracket
// then pop it from the stack
if (OpenBracketTypes.contains(letter)) {
brackets.push(letter);
} else if (CloseBracketTypes.contains(letter)) {
if (!CloseBracketTypes.isBracketMatching(letter, brackets)) {
return false;
} else {
brackets.pop();
}
}
}
// If the stack is not empty then the syntax is incorrect
if (!brackets.isEmpty()) {
bracketsMatched = false;
}
}
return bracketsMatched;
}
/**
* @param args
*/
public static void main(String[] args) {
String words = "[[][][]Anfield[[]([])[]]becons()]";
boolean isSyntaxCorrect = SyntaxChecker.matchBrackets(words);
if (isSyntaxCorrect) {
System.out.println("The syntax is correct");
} else {
System.out.println("Incorrect syntax");
}
}
}
отзывы о приветствуется. Пожалуйста, критикуйте, если вы обнаружите, что что-то не так или бесполезно. Я просто пытаюсь учиться.
import java.util.*;
public class Parenthesis
{
public static void main (String ...argd)
{
Scanner sc=new Scanner(System.in);
System.out.println("enetr string");
String s=sc.nextLine();
Stack<Character> st=new Stack<Character>();
for (int i=0;i<s.length();++i)
{
if((s.charAt(i)=='(')||(s.charAt(i)=='{')||(s.charAt(i)=='['))
{
st.push(s.charAt(i));
}
else if(st.isEmpty()==false)
{
switch(s.charAt(i))
{
case']':
if(st.pop()!='[')
{
System.out.println("unbalanced");
System.exit(0);
}
break;
case'}':
if(st.pop()!='{')
{
System.out.println("unbalanced");
System.exit(0);
}
break;
case')':
if(st.pop()!='(')
{
System.out.println("unbalanced");
System.exit(0);
}
break;
}
}
}
if(st.isEmpty())
{
System.out.println("balanced paranthesis");
}
else
System.out.println("not balance");
}
}