入力文字列がバランスが取れているかどうかをテストしたい。一致する左括弧と右括弧、大括弧または中括弧がある場合、バランスが取れています。
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;
}
何をするかを選択するのに問題があります。すべての開き括弧、閉じ括弧、括弧、または中括弧をスタックに入れてからポップアウトする必要がありますか? それらを取り出した場合、それは本当にどのように役立ちますか?
1) 開き括弧ごとに:{ [ (スタックにプッシュします。
2) 閉じ括弧ごとに:} ] )スタックからポップし、括弧のタイプが一致するかどうかを確認します。そうでない場合は戻り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
アイデアはそれです -
( [ {に、それをスタックにプッシュします。) ] }は、一致する開きブレース( [ }をスタックからポップしてみてください。一致する左中括弧が見つからない場合、文字列はバランスが取れていません。大まかに言えば、バランスがとれている場合、スタックは空であることを意味します。
そのためには、解析時にスタックをポップする必要があります}
追加の要件は、}が先行する{か、ポップされた文字が a であることを確認することです{。
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");
}
}
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");
}
}
}
これに関するフィードバックは大歓迎です。何かが間違っている、または役に立たないことがわかったら、批判してください。私はただ学ぼうとしています。