华为OD机试 - 最大括号深度 - 栈stack（Python/JS/C/C++ 2025 A卷 100分）

华为OD机试 2025A卷题库疯狂收录中，刷题点这里

专栏导读

本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。

一、题目描述

现有一字符串仅由(、)、 {、}、[、 ]六种括号组成。

若字符串满足以下条件之一，则为无效字符串：任一类型的左右括号数量不相等

存在未按正确顺序先左(，后右)闭合的括号，输出括号的最大嵌套深度，若字符串无效则输出0。

0<=字符串长度<=100000

二、输入描述

一个只包括(、)、 {、}、[、 ]的字符串。

三、输出描述

整数，最大的括号深度

输入	输出	说明
[]	1	有效字符串，最大嵌套深度1
[{[]}()]	3	有效字符串，最大嵌套深度3

四、解题思路

先明确一点，最大括号深度指的是有效闭合括号的嵌套深度，而不是有效闭合括号的组合数。

1. 利用栈的特效；
2. 如果是左括号{[(，则加入栈stack，有效深度+1；
3. 如果是右括号，则弹出栈顶元素；
   • 与当前右括号进行比较；
   • 如果匹配，弹出栈顶元素，有效深度-1；
   • 如果不匹配，直接返回0；
   • 取最大深度max；
4. 如果不是有效括号，则输出"input error"；
5. 遍历完毕后，栈stack为空时，表示所有左右括号都可配对，输出最大深度max即可，否则输出0

五、Python算法源码

# 导入所需模块
import sys

def main():
    # 读取输入字符串
    input_str = sys.stdin.readline().strip()
    stack = []
    # 定义右括号到左括号的映射
    bracket_map = {')': '(', '}': '{', ']': '['}
    
    current_depth = 0
    max_depth = 0
    
    for ch in input_str:
        if ch in bracket_map.values():  # 左括号
            stack.append(ch)
            current_depth += 1
            if current_depth > max_depth:
                max_depth = current_depth
        elif ch in bracket_map:  # 右括号
            if not stack or stack.pop() != bracket_map[ch]:
                print(0)
                return
            current_depth -= 1
        else:  # 无效字符
            print("input error")
            return
    
    # 遍历结束后，检查栈是否为空
    if not stack:
        print(max_depth)
    else:
        print(0)

if __name__ == "__main__":
    main()

六、JavaScript算法源码

// 使用Node.js的readline模块读取输入
const readline = require('readline');

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.on('line', (input) => {
    const bracketMap = {
        ')': '(',
        '}': '{',
        ']': '['
    };
    
    const stack = [];
    let currentDepth = 0;
    let maxDepth = 0;
    
    for (let ch of input) {
        if (['(', '{', '['].includes(ch)) { // 左括号
            stack.push(ch);
            currentDepth++;
            if (currentDepth > maxDepth) {
                maxDepth = currentDepth;
            }
        } else if ([')', '}', ']'].includes(ch)) { // 右括号
            if (stack.length === 0 || stack.pop() !== bracketMap[ch]) {
                console.log(0);
                rl.close();
                return;
            }
            currentDepth--;
        } else { // 无效字符
            console.log("input error");
            rl.close();
            return;
        }
    }
    
    if (stack.length === 0) {
        console.log(maxDepth);
    } else {
        console.log(0);
    }
    rl.close();
});

七、C算法源码

#include <stdio.h>
#include <string.h>

// 定义栈的最大大小
#define MAX_SIZE 100000

int main() {
    char input[MAX_SIZE + 1];
    if (fgets(input, sizeof(input), stdin) == NULL) {
        printf("0\n");
        return 0;
    }
    // 去除换行符
    size_t len = strlen(input);
    if (len > 0 && input[len-1] == '\n') {
        input[len-1] = '\0';
        len--;
    }
    
    char stack[MAX_SIZE];
    int top = -1;
    // 定义右括号到左括号的映射
    char bracket_map[128] = {0};
    bracket_map[')'] = '(';
    bracket_map['}'] = '{';
    bracket_map[']'] = '[';
    
    int currentDepth = 0;
    int maxDepth = 0;
    
    for (size_t i = 0; i < len; i++) {
        char ch = input[i];
        if (ch == '(' || ch == '{' || ch == '[') { // 左括号
            stack[++top] = ch;
            currentDepth++;
            if (currentDepth > maxDepth) {
                maxDepth = currentDepth;
            }
        }
        else if (ch == ')' || ch == '}' || ch == ']') { // 右括号
            if (top == -1 || stack[top] != bracket_map[ch]) {
                printf("0\n");
                return 0;
            }
            top--;
            currentDepth--;
        }
        else { // 无效字符
            printf("input error\n");
            return 0;
        }
    }
    
    if (top == -1) {
        printf("%d\n", maxDepth);
    }
    else {
        printf("0\n");
    }
    
    return 0;
}

八、C++算法源码

#include <bits/stdc++.h>
using namespace std;

int main(){
    string input;
    getline(cin, input);
    stack<char> s;
    // 定义右括号到左括号的映射
    unordered_map<char, char> bracketMap = {
        {')', '('},
        {'}', '{'},
        {']', '['}
    };
    
    int currentDepth = 0;
    int maxDepth = 0;
    
    for(char ch : input){
        if(bracketMap.find(ch) == bracketMap.end() && (ch == '(' || ch == '{' || ch == '[')){
            // 左括号
            s.push(ch);
            currentDepth++;
            if(currentDepth > maxDepth){
                maxDepth = currentDepth;
            }
        }
        else if(bracketMap.find(ch) != bracketMap.end()){
            // 右括号
            if(s.empty() || s.top() != bracketMap[ch]){
                cout << "0" << endl;
                return 0;
            }
            s.pop();
            currentDepth--;
        }
        else{
            // 无效字符
            cout << "input error" << endl;
            return 0;
        }
    }
    
    if(s.empty()){
        cout << maxDepth << endl;
    }
    else{
        cout << "0" << endl;
    }
    
    return 0;
}

🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2025 A卷 200分）

🏆本文收录于，华为OD机试真题（Python/JS/C/C++）

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。