Java 中的平衡括号

17 Mar 2025 | 5 分钟阅读

平衡括号问题是一个常见的编程问题，也称为平衡方括号。面试官经常提出这个问题，要求我们验证给定字符串中的方括号是否平衡。

诸如“ ( ”、“ ) ”、“ [ ”、“ ] ”、“ { ”和“ } ”之类的字符被视为方括号。

如果开括号出现在相应闭括号的左侧，则称一组括号为匹配对。

如果字符串中的括号不匹配，则括号对不平衡。

同样，包含非括号字符（如 a-z、A-Z、0-9 以及 #、 $、 @ 等其他特殊字符）的字符串也被视为不平衡。

示例 "{[(])}"

这是一个不平衡的输入字符串，因为圆括号对“()”包围了一个不平衡的闭合方括号“]”，而方括号对“[]”包围了一个不平衡的开圆括号“(”。

一个包含括号的字符串如果满足以下条件，则称其为平衡的：

每个相应的开括号都存在一个匹配的闭括号并位于其右侧。
平衡括号内部包含的括号也应该是平衡的。
它不应包含任何非括号字符。

注意 1：null 被视为平衡的。

注意 2：空字符串被视为平衡的。

算法（双端队列）

首先，我们声明一个字符栈。
将输入字符串转换为字符数组。
遍历输入字符串（通过遍历字符数组）。
1. 如果当前字符是起始括号（'(' 或 '{' 或 '['），则将其压入栈。
2. 如果当前字符是闭合括号，则从栈中弹出。如果弹出的字符与起始括号不匹配，则括号不平衡。
遍历完成后，如果栈中还有起始括号，则括号不平衡。

我们可以使用简单的 for 循环、双端队列和栈来实现平衡括号的代码。

BalancedParenthesesExample1.java

// import required classes and package, if any 
 
import java.util.*; 
 
// create class BalancedParenthesesExample1 for implementing Balanced Parentheses using stack 
public class BalancedParenthesesExample1 { 
    
    // create method balancedParenthesis() to check whether the input string is balanced or not 
    @SuppressWarnings({ "rawtypes", "unchecked" }) 
    public static boolean balancedParenthesis(String inputStr) { 
        
        // create an empty stack 
        Stack stack = new Stack(); 
        
        // convert inputStr to char array 
        char[] charArray = inputStr.toCharArray(); 
        
        // iterate charArray 
        for (int i = 0; i < charArray.length; i++) { 
            
            // get char 
            char current = charArray[i]; 
            
            //check whether current is '(', '[' or '{' 
            if (current == '{' || current == '[' || current == '(') { 
                // push current to stack 
                stack.push(current); 
                continue; 
            } 
            // if stack is empty, return false 
            if (stack.isEmpty()) {  
                return false; 
            } 
            
            // use switch statement to pop element from stack and if it is '(', '[' or '{', return false 
            char popChar; 
            switch (current) { 
                case ')': 
                popChar = (char) stack.pop(); 
                if (popChar == '{' || popChar == '[') 
                    return false; 
                break; 
                case '}': 
                popChar = (char) stack.pop(); 
                if (popChar == '(' || popChar == '[') 
                    return false; 
                break; 
                case ']': 
                popChar = (char) stack.pop(); 
                if (popChar == '(' || popChar == '{') 
                    return false; 
                break; 
            } 
        } 
        return (stack.isEmpty()); 
    } 
    // main() method start 
    public static void main(String[] args) { 
        
        String inputStr; 
        
        // create an instance of Scanner class 
        Scanner sc = new Scanner(System.in); 
        
        System.out.println("Enter input string to check:"); 
        // take input sring from user 
        inputStr = sc.nextLine(); 
        
        // call balancedParenthesis() method to check whether input string is balanced of not 
        if (balancedParenthesis(inputStr)) 
            System.out.println("Input string "+inputStr+" is balanced."); 
        else 
            System.out.println("Input string "+inputStr+" is not balanced."); 
    } 
}

输出

BalancedParenthesesExample2.java

// import required classes and package if any 
import java.util.Scanner; 
 
//create class BalancedParenthesesExample2 for implementing Balanced Parentheses using simple for loop 
public class BalancedParenthesesExample2 { 
    // main() method start 
    public static void main(String[] args) 
    { 
        
        String inputStr; 
        int i, length, j=0, count=0; 
        char current, ch; 
        
        // create an empty stack 
        char[] stack = new char[20]; 
        
        // create an instance of Scanner class 
        Scanner sc = new Scanner(System.in); 
        
        System.out.print("Enter an expression to check whether it is balanced or not: \n"); 
        inputStr = sc.nextLine(); 
        
        // close Scanner class object 
        sc.close(); 
        
        // get length of inputStr 
        length = inputStr.length(); 
        
        // use for loop for iterating input string 
        for(i = 0; i < length; i++) { 
            
            current = inputStr.charAt(i); 
            
            // check whether current is '(', '{', or '[' 
            if(current =='(' || current =='{' || current =='[') { 
                stack[j] = current; 
                j++;	// increment counter j 
                count = 1;	// set count to 1 
            } else if(current == ')') {		//if current char is ')' 
                if(count == 1) //if count is 1, decrement counter j 
                    j--; 
                ch = stack[j];	//store stack[j] to ch 
                if(stack.length == 0 || ch != '(') {	//if stack is empty or ch is an opening bracket '(', parentheses is not balanced  
                    System.out.println("\nUnbalanced Parentheses!"); 
                    return; 
                } 
            } else if(current == '}') {	//if current char is '}' 
                if(count == 1)	//if count is 1, decrement counter j 
                    j--; 
                ch = stack[j];	//store stack[j] to ch 
                if(stack.length == 0 || ch != '{') {	//if stack is empty or ch is an opening bracket '{', parentheses is not balanced 
                    System.out.println("\nUnbalanced Parentheses!"); 
                    return; 
                } 
            } else if(current == ']') {	//if current char is '}' 
                if(count == 1)	//if count is 1, decrement counter j 
                    j--; 
                ch = stack[j];	//store stack[j] to ch 
                if(stack.length == 0 || ch != '[') {	//if stack is empty or ch is an opening bracket '[', parentheses is not balanced 
                    System.out.println("\nUnbalanced Parentheses!"); 
                    return; 
                } 
            } 
        } 
        
        System.out.println("\nBalanced Parentheses."); 
    } 
} 

输出

BalancedParenthesesExample3.java

//import required classes and package, if any 
 
import java.util.Deque; 
import java.util.LinkedList; 
import java.util.Scanner; 
 
//create class BalancedParenthesesExample3 for implementing Balanced Parentheses using Deque 
public class BalancedParenthesesExample3 { 
    
    // main() method start 
    public static void main(String[] args) 
    { 
        
        String inputStr; 
        
        // create an empty deque using LinkedList 
        Deque<Character> deque = new LinkedList<>(); 
        
        // create an instance of Scanner class 
        Scanner sc = new Scanner(System.in); 
        
        System.out.print("Enter an expression to check whether it is balanced or not: \n"); 
        inputStr = sc.nextLine(); 
        
        // close Scanner class object 
        sc.close(); 
        
        //iterate input string using for 
        for(char ch : inputStr.toCharArray()) { 
            // add element to deque if ch = '{', ch = '[', or ch = '(' 
            if(ch == '{' || ch == '[' || ch == '(') { 
                deque.add(ch); 
            } else { 
                // if deque is not empty 
                if(! deque.isEmpty()) { 
                    if((deque.peekFirst() == '{' && ch == '}') 
                       || (deque.peekFirst() == '[' && ch == ']') 
                       || (deque.peekFirst() == '(' && ch == ')')) { 
                           deque.removeFirst(); 
                       } 
                }else { 
                    System.out.println("\nUnbalanced Parentheses2."); 
                } 
            } 
        } 
        System.out.println("\nBalanced Parentheses."); 
    } 
} 

输出

下一个主题Java 中的凯撒密码程序

← 上一个下一个 →

Java 中的平衡括号

示例 "{[(])}"

注意 1：null 被视为平衡的。

注意 2：空字符串被视为平衡的。

算法（双端队列）

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中的平衡括号

示例 "{[(])}"

注意 1：null 被视为平衡的。

注意 2：空字符串被视为平衡的。

算法（双端队列）

相关帖子

How do you swap two string variables without using third or temp variable in java

Static Function in Java

How to Create Package in Java

Session Tracking in Java

使用 Java 泛型将 Set 转换为 Stream 的程序

Java 运算符选择题

Java Program to Find the Largest Clique in a Planar Graph

Set in Java

No Java Virtual Machine was Found

Java 中的图像处理 - 亮度增强

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器