Demostración animada de aplicación de pila: Coincidencia de paréntesis

给定一个表达式字符串 exp ，编写一个程序来检查给定表达式中“{”, “}”, “(”, “)”, “[”, “]”的对和顺序是否正确。

示例：

输入：exp = “[()]{}{[()()]()}”
输出：Balanced
解释： 所有括号格式正确

输入：exp = “[(])”
输出：Not Balanced
解释：1 和 4 括号不平衡，因为
在右括号 '(' 之前有一个右括号 ']'

使用Stack 检查平衡括号表达式：

这个想法是将所有左括号放入堆栈中。每当您击中右括号时，请搜索堆栈顶部是否是相同性质的左括号。如果成立，则弹出堆栈并继续迭代。最后如果堆栈为空，则意味着所有括号都是平衡的或格式良好的。否则，它们就不平衡。

插图：
下面是上述方法的插图。

请按照下面提到的步骤来实现这个想法：

声明一个字符堆栈（例如 temp ）。
现在遍历字符串exp。
- 如果当前字符是起始括号（ '(' 或 '{' 或 '[' ），则将其压入堆栈。
- 如果当前字符是右括号（ ')' 或 '}' 或 ']' ），则从堆栈中弹出，如果弹出的字符是匹配的起始括号，则可以。
- 否则括号 不平衡 。
完成遍历后，如果堆栈中留下一些起始括号，则表达式为 Not Balanced ，否则为 Balanced 。

下面是上述方法的实现：

C++

              
                
                    // C++ program to check for balanced brackets.
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if brackets are balanced
bool areBracketsBalanced(string expr)
{
    // Declare a stack to hold the previous brackets.
    stack<char> temp;
    for (int i = 0; i < expr.length(); i++) {
        if (temp.empty()) {
             
                        
            // If the stack is empty 
            // just push the current bracket
            temp.push(expr[i]);
        }
        else if ((temp.top() == '(' && expr[i] == ')')
                 || (temp.top() == '{' && expr[i] == '}')
                 || (temp.top() == '[' && expr[i] == ']')) {
             
                        
            // If we found any complete pair of bracket
            // then pop
            temp.pop();
        }
        else {
            temp.push(expr[i]);
        }
    }
    if
                          (temp.empty()) {
         
        // If stack is empty return true
        return true;
    }
    return false;
}
 
// Driver code
int main()
{
    string expr = "{()}[]";
 
    // Function call
    if
                          (areBracketsBalanced(expr))
        cout << "Balanced";
    else
        cout << "Not Balanced";
    return 0;
}

                  

              
            

C

              
                
                    #include <stdio.h>
                        
#include <stdlib.h>
#define bool int
 
// Structure of a stack node
                        
struct sNode {
    char data;
    struct sNode* next;
};
 
// Function to push an item to stack
void push(struct sNode** top_ref, int new_data);
 
// Function to pop an item from stack
int pop(struct sNode** top_ref);
 
// Returns 1 if character1 and character2 are matching left
// and right Brackets
                        
bool isMatchingPair(char character1, char character2)
{
    if
                          (character1 == '(' && character2 == ')')
        return 1;
    else if (character1 == '{' && character2 == '}')
        return 1;
    else if (character1 == '[' && character2 == ']')
        return 1;
    else
        return 0;
}
 
// Return 1 if expression has balanced Brackets
bool areBracketsBalanced(char exp[])
{
    int
                          i = 0;
 
    // Declare an empty character stack
    struct sNode* stack = NULL;
 
    // Traverse the given expression to check matching
    // brackets
    while (exp[i]) {
        // If the exp[i] is a starting bracket then push
        // it
        if (exp[i] == '{' || exp[i] == '(' || exp[i] == '[')
            push(&stack, exp[i]);
 
        // If exp[i] is an ending bracket then pop from
        // stack and check if the popped bracket is a
        // matching pair*/
        if (exp[i] == '}' || exp[i] == ')'
            || exp[i] == ']') {
                        
 
            // If we see an ending bracket without a pair
            // then return false
            if (stack == NULL)
                return 0;
 
            // Pop the top element from stack, if it is not
            // a pair bracket of character then there is a
            // mismatch.
            // his happens for expressions like {(})
            else if (!isMatchingPair(pop(&stack), exp[i]))
                return 0;
        }
        i++;
    }
 
    // If there is something left in expression then there
    // is a starting bracket without a closing
    // bracket
    if
                          (stack == NULL)
        return 1; // balanced
    else
        return 0; // not balanced
}
 
// Driver code
int main()
{
    char exp[100] = "{()}[]";
 
    // Function call
    if
                          (areBracketsBalanced(exp))
        printf("Balanced \n");
    else
        printf("Not Balanced \n");
    return 0;
}
 
// Function to push an item to stack
void push(struct sNode** top_ref, int new_data)
{
    // allocate node
    struct sNode* new_node
        = (struct sNode*)malloc(sizeof(struct sNode));
 
    if
                          (new_node == NULL) {
        printf("Stack overflow n");
        getchar();
        exit(0);
    }
 
    // put in the data
    new_node->data = new_data;
 
    // link the old list of the new node
    new_node->next = (*top_ref);
 
    // move the head to point to the new node
    (*top_ref) = new_node;
}
 
// Function to pop an item from stack
int pop(struct sNode** top_ref)
{
    char res;
    struct sNode* top;
 
    // If stack is empty then error
    if
                          (*top_ref == NULL) {
        printf("Stack overflow n");
        getchar();
        exit(0);
    }
    else {
        top = *top_ref;
        res = top->data;
        *top_ref = top->next;
        free(top);
        return res;
    }
}

                  

              
            

Java

              
                
                    // Java program for checking
                        
// balanced brackets
import java.util.*;
 
public class BalancedBrackets {
 
    // function to check if brackets are balanced
    static
                          boolean areBracketsBalanced(String expr)
    {
        // Using ArrayDeque is faster than using Stack class
        Deque<Character> stack
            = new ArrayDeque<Character>();
 
        // Traversing the Expression
        for (int
                          i = 0; i < expr.length(); i++) {
            char x = expr.charAt(i);
 
            if (x == '('
                          || x == '[' || x == '{') {
                        
                // Push the element in the stack
                stack.push(x);
                continue;
            }
 
            // If current character is not opening
            // bracket, then it must be closing. So stack
            // cannot be empty at this point.
            if (stack.isEmpty())
                return false;
                        
            char check;
            switch (x) {
            case ')':
                        
                check = stack.pop();
                if (check == '{' || check == '[')
                    return false;
                        
                break;
 
            case '}':
                        
                check = stack.pop();
                if (check == '(' || check == '[')
                    return false;
                        
                break;
 
            case ']':
                        
                check = stack.pop();
                if (check == '(' || check == '{')
                    return false;
                        
                break;
            }
        }
 
        // Check Empty Stack
        return (stack.isEmpty());
    }
 
    // Driver code
    public
                          static void main(String[] args)
    {
        String expr = "([{}])";
 
        // Function call
        if (areBracketsBalanced(expr))
            System.out.println("Balanced ");
        else
            System.out.println("Not Balanced ");
    }
}

                  

              
            

Python3

              
                
                    # Python3 program to check for
# balanced brackets.
 
# function to check if
# brackets are balanced
                        
 
 
def areBracketsBalanced(expr):
    stack = []
                        
 
    # Traversing the Expression
    for
                          char in expr:
        if char in
                          ["(", "{", "["]:
 
            # Push the element in the stack
            stack.append(char)
        else:
 
            # IF current character is not opening
            # bracket, then it must be closing.
            # So stack cannot be empty at this point.
            if not stack:
                        
                return False
            current_char = stack.pop()
            if current_char == '(':
                if char !=
                          ")":
                    return False
            if current_char == '{':
                if char !=
                          "}":
                    return False
            if current_char == '[':
                if char !=
                          "]":
                    return False
 
    # Check Empty Stack
    if
                          stack:
        return False
    return
                          True
 
 
# Driver Code
if __name__ ==
                          "__main__":
    expr = "{()}[]"
 
    # Function call
    if
                          areBracketsBalanced(expr):
        print("Balanced")
    else:
        print("Not Balanced")
 
# This code is contributed by AnkitRai01 and improved
# by Raju Pitta

                  

              
            

C＃

              
                
                    // C# program for checking
                        
// balanced Brackets
using System;
using System.Collections.Generic;
 
public class BalancedBrackets {
    public
                          class stack {
        public int top = -1;
        public char[] items = new char[100];
 
        public void push(char x)
                        
        {
            if (top == 99) {
                Console.WriteLine("Stack full");
            }
            else {
                items[++top] = x;
            }
        }
 
        char pop()
        {
            if (top == -1) {
                Console.WriteLine("Underflow error");
                return '\0';
                        
            }
            else {
                char element = items[top];
                top--;
                return element;
            }
        }
 
        Boolean isEmpty()
        {
            return (top == -1) ? true : false;
        }
    }
 
    // Returns true if character1 and character2
    // are matching left and right brackets */
    static
                          Boolean isMatchingPair(char character1,
                                  char character2)
    {
        if (character1 == '(' && character2 == ')')
            return true;
                        
        else if (character1 == '{' && character2 == '}')
            return true;
                        
        else if (character1 == '[' && character2 == ']')
            return true;
                        
        else
            return false;
                        
    }
 
    // Return true if expression has balanced
    // Brackets
    static
                          Boolean areBracketsBalanced(char[] exp)
    {
        // Declare an empty character stack */
        Stack<char> st = new Stack<char>();
 
        // Traverse the given expression to
        //   check matching brackets
        for (int
                          i = 0; i < exp.Length; i++) {
            // If the exp[i] is a starting
            // bracket then push it
            if (exp[i] == '{' || exp[i] == '('
                || exp[i] == '[')
                st.Push(exp[i]);
 
            //  If exp[i] is an ending bracket
            //  then pop from stack and check if the
            //   popped bracket is a matching pair
            if (exp[i] == '}' || exp[i] == ')'
                || exp[i] == ']') {
 
                // If we see an ending bracket without
                //   a pair then return false
                if (st.Count == 0) {
                    return false;
                        
                }
 
                // Pop the top element from stack, if
                // it is not a pair brackets of
                // character then there is a mismatch. This
                // happens for expressions like {(})
                else if (!isMatchingPair(st.Pop(),
                                         exp[i])) {
                    return false;
                        
                }
            }
        }
 
        // If there is something left in expression
        // then there is a starting bracket without
        // a closing bracket
 
        if (st.Count == 0)
            return true; // balanced
        else {
            // not balanced
            return false;
                        
        }
    }
 
    // Driver code
    public
                          static void Main(String[] args)
    {
        char[] exp = { '{', '(', ')', '}', '[', ']' };
 
        // Function call
        if (areBracketsBalanced(exp))
            Console.WriteLine("Balanced ");
        else
            Console.WriteLine("Not Balanced ");
    }
}
 
// This code is contributed by 29AjayKumar

                  

              
            

JavaScript

              
                
                    <script>
 
// Javascript program for checking
// balanced brackets
 
// Function to check if brackets are balanced
function areBracketsBalanced(expr)
{
     
    // Using ArrayDeque is faster
    // than using Stack class
    let stack = [];
 
    // Traversing the Expression
    for(let i = 0; i < expr.length; i++)
                        
    {
        let x = expr[i];
 
        if (x == '('
                          || x == '[' || x == '{')
                        
        {
             
                        
            // Push the element in the stack
            stack.push(x);
            continue;
        }
 
        // If current character is not opening
        // bracket, then it must be closing. 
        // So stack cannot be empty at this point.
        if (stack.length == 0)
            return false;
                        
             
                        
        let check;
        switch (x){
        case ')':
                        
            check = stack.pop();
            if (check == '{' || check == '[')
                return false;
                        
            break;
 
        case '}':
                        
            check = stack.pop();
            if (check == '(' || check == '[')
                return false;
                        
            break;
 
        case ']':
                        
            check = stack.pop();
            if (check == '(' || check == '{')
                return false;
                        
            break;
        }
    }
 
    // Check Empty Stack
    return
                          (stack.length == 0);
}
 
// Driver code
let expr = "([{}])";
 
// Function call
if (areBracketsBalanced(expr))
    document.write("Balanced ");
else
    document.write("Not Balanced ");
 
// This code is contributed by rag2127
 
</script>

                  

              
            

输出

均衡

时间复杂度： O(N)，对大小为 N 的字符串迭代一次。
辅助空间： 堆栈的 O(N)。

在不使用堆栈的情况下检查平衡括号表达式：

以下是应遵循的步骤：

用 -1 初始化变量 i 。
遍历字符串并
- 如果它是左括号，则将计数器加 1，并将字符串中的 第 i ^{个字符替换为左括号。}
- 否则，如果它是相同的相应左括号（左括号存储在 exp[i] 中）的右括号，则将 i 减1。
最后，如果我们得到 i = -1 ，那么字符串是平衡的，我们将返回 true。否则，该函数将返回 false。

下面是上述方法的实现：

C++
Java
C＃
Python3
JavaScript

C++

              
                
                    #include <iostream>
 
using namespace std;
 
 bool areBracketsBalanced(string s) {
                        
        int i=-1;
        for(auto& ch:s){
            if(ch=='(' || ch=='{'
                          || ch=='[')
                        
                s[++i]=ch;
            else{
                if(i>=0 && ((s[i]=='(' && ch==')') || (s[i]=='{' && ch=='}') || (s[i]=='[' && ch==']')))
                    i--;
                else
                    return false;
            }
        }
        return i==-1;
    }
 
int main()
{
    string expr = "{()}[]";
 
    // Function call
    if
                          (areBracketsBalanced(expr))
        cout << "Balanced";
    else
        cout << "Not Balanced";
    return 0;
}

                  

              
            

Java

              
                
                    public class GFG {
    public
                          static boolean areBracketsBalanced(String s)
    {
        int i = -1;
        char[] stack = new char[s.length()];
        for (char
                          ch : s.toCharArray()) {
            if (ch == '('
                          || ch == '{' || ch == '[')
                        
                stack[++i] = ch;
            else {
                if (i >= 0
                        
                    && ((stack[i] == '(' && ch == ')')
                        || (stack[i] == '{' && ch == '}')
                        || (stack[i] == '[' && ch == ']')))
                    i--;
                else
                    return false;
                        
            }
        }
        return i == -1;
    }
 
    public
                          static void main(String[] args)
    {
        String expr = "{()}[]";
 
        // Function call
        if (areBracketsBalanced(expr))
            System.out.println("Balanced");
        else
            System.out.println("Not Balanced");
    }
}

                  

              
            

C＃

              
                
                    // c# implementation
 
using System;
 
public class GFG {
    static
                          bool areBracketsBalanced(string s) {
        int i = -1;
        char[] stack = new char[s.Length];
        foreach (char
                          ch in s) {
                        
            if (ch == '('
                          || ch == '{' || ch == '[')
                        
                stack[++i] = ch;
            else {
                if (i >= 0 && ((stack[i] == '('
                          && ch == ')') || (stack[i] == '{' && ch == '}') || (stack[i] == '[' && ch == ']')))
                    i--;
                else
                    return false;
                        
            }
        }
        return i == -1;
    }
 
    static
                          void Main() {
        string expr = "{()}[]";
 
        // Function call
        if (areBracketsBalanced(expr))
            Console.WriteLine("Balanced");
        else
            Console.WriteLine("Not Balanced");
    }
}
// ksam24000

                  

              
            

Python3

              
                
                    def are_brackets_balanced(s):
    stack = []
                        
    for
                          ch in s:
                        
        if ch in
                          ('(', '{', '['):
            stack.append(ch)
        else:
            if stack and
                          ((stack[-1] == '(' and
                          ch ==
                          ')') or
                        
                          (stack[-1] == '{' and ch == '}') or
                          (stack[-1] == '[' and ch == ']')):
                stack.pop()
            else:
                return False
    return
                          not stack
 
expr = "{()}[]"
 
# Function call
if are_brackets_balanced(expr):
    print("Balanced")
else:
    print("Not Balanced")

                  

              
            

JavaScript

              
                
                    function areBracketsBalanced(s) {
    let i = -1;
    let stack = [];
    for
                          (let ch of s) {
        if (ch === '('
                          || ch === '{' || ch === '[') {
                        
            stack.push(ch);
            i++;
        } else {
            if (i >= 0 && ((stack[i] === '('
                          && ch === ')') || (stack[i] === '{' && ch === '}') || (stack[i] === '[' && ch === ']'))) {
                stack.pop();
                i--;
            } else {
                return false;
                        
            }
        }
    }
    return
                          i === -1;
}
 
let expr = "{()}[]";
 
// Function call
if (areBracketsBalanced(expr))
    console.log("Balanced");
else
    console.log("Not Balanced");

                  

              
            

输出

均衡

时间复杂度 ：O(N)，对大小为 N 的字符串迭代一次。
辅助空间 ：O(1)

使用Stack 检查平衡括号表达式 ：

C++

C

Java

Python3

C＃

JavaScript

在不使用堆栈的情况下检查平衡括号表达式：

C++

Java

C＃

Python3

JavaScript

使用Stack 检查平衡括号表达式：