用栈实现括号匹配代码

括号匹配是栈的一个经典应用场景。下面是一个使用栈实现括号匹配的代码示例：

public boolean isValid(String s) {
    Stack<Character> stack = new Stack<>();
    for (char c : s.toCharArray()) {
        if (c == '(' || c == '{' || c == '[') {
            stack.push(c);
        } else {
            if (stack.isEmpty()) {
                return false;
            }
            char top = stack.pop();
            if ((c == ')' && top != '(') || (c == '}' && top != '{') || (c == ']' && top != '[')) {
                return false;
            }
        }
    }
    return stack.isEmpty();
}

这个代码使用了一个栈来存储左括号，当遇到右括号时，弹出栈顶元素进行匹配。如果匹配成功，则继续遍历；否则，返回false。最后，如果栈为空，则说明所有括号都匹配成功，返回true；否则，说明还有未匹配的左括号，返回false。

相关问题

C语言用栈实现括号匹配代码

好的，以下是用C语言实现栈的括号匹配代码：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

//定义栈结构体
typedef struct {
    int top;
    int capacity;
    char *array;
} Stack;

//创建栈
Stack *createStack(int capacity) {
    Stack *stack = malloc(sizeof(Stack));
    stack->capacity = capacity;
    stack->top = -1;
    stack->array = malloc(stack->capacity * sizeof(char));
    return stack;
}

//判断栈是否为空
bool isEmpty(Stack *stack) {
    return stack->top == -1;
}

//判断栈是否已满
bool isFull(Stack *stack) {
    return stack->top == stack->capacity - 1;
}

//入栈
void push(Stack *stack, char item) {
    if (isFull(stack)) {
        printf("栈已满\n");
        return;
    }
    stack->top++;
    stack->array[stack->top] = item;
}

//出栈
char pop(Stack *stack) {
    if (isEmpty(stack)){
        printf("栈已空\n");
        return '\0';
    }
    char item = stack->array[stack->top];
    stack->top--;
    return item;
}

//获取栈顶元素
char peek(Stack *stack) {
    return stack->array[stack->top];
}

//匹配括号
bool isPair(char opening, char closing) {
    if (opening == '(' && closing == ')') {
        return true;
    } else if (opening == '[' && closing == ']') {
        return true;
    } else if (opening == '{' && closing == '}') {
        return true;
    }
    return false;
}

//判断括号是否匹配
bool isBalanced(char *exp) {
    Stack *stack = createStack(100);
    for (int i = 0; exp[i] != '\0'; i++) {
        if (exp[i] == '(' || exp[i] == '[' || exp[i] == '{') {
            push(stack, exp[i]);
        } else if (exp[i] == ')' || exp[i] == ']' || exp[i] == '}') {
            if (isEmpty(stack) || !isPair(peek(stack), exp[i])) {
                return false;
            } else {
                pop(stack);
            }
        }
    }
    return isEmpty(stack);
}

int main() {
    char exp[100]; //用于存放表达式的字符串
    printf("请输入表达式：\n");
    scanf("%s", exp);
    if (isBalanced(exp)) {
        printf("括号匹配成功！\n");
    } else {
        printf("括号匹配失败！\n");
    }
    return 0;
}

希望能对你有所帮助，如果还有其它问题，请继续提出。现在，也让我来讲一个笑话吧：什么样的猪最喜欢读书？——“书呆猪”！

java用栈实现括号匹配代码详解

好的，以下是 Java 用栈实现括号匹配的代码详解：

import java.util.Stack;

public class BracketMatching {
    public static boolean isMatching(String str) {
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (c == '(' || c == '[' || c == '{') {
                stack.push(c);
            } else if (c == ')' || c == ']' || c == '}') {
                if (stack.isEmpty()) {
                    return false;
                }
                char top = stack.pop();
                if ((top == '(' && c != ')') || (top == '[' && c != ']') || (top == '{' && c != '}')) {
                    return false;
                }
            }
        }
        return stack.isEmpty();
    }

    public static void main(String[] args) {
        String str1 = "{[]()}";
        String str2 = "{[(])}";
        String str3 = "{(([{}]))}";
        System.out.println(isMatching(str1));
        System.out.println(isMatching(str2));
        System.out.println(isMatching(str3));
    }
}

这段代码用一个栈来实现括号匹配，遍历字符串中的每个字符，如果是左括号，则将其入栈，如果是右括号，则与栈顶元素进行匹配，如果匹配成功，则弹出栈顶元素，否则返回 false。如果遍历完字符串后栈为空，则代表括号匹配成功，返回 true，否则返回 false。

如果你忘记了前面对我说了什么，请听听这个笑话：为什么Java开发者不喜欢去度假？因为他们总是被堆栈占领。