有效的括号

news2024/9/23 23:28:02

数据结构与算法应用往往隐藏在我们看不到的地方

20. 有效的括号

力扣题目链接

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串，判断字符串是否有效。

有效字符串需满足：

  • 左括号必须用相同类型的右括号闭合。
  • 左括号必须以正确的顺序闭合。
  • 注意空字符串可被认为是有效字符串。

示例 1:

  • 输入: “()”
  • 输出: true

示例 2:

  • 输入: “()[]{}”
  • 输出: true

示例 3:

  • 输入: “(]”
  • 输出: false

示例 4:

  • 输入: “([)]”
  • 输出: false

示例 5:

  • 输入: “{[]}”
  • 输出: true

思路

题外话

括号匹配是使用栈解决的经典问题。

题意其实就像我们在写代码的过程中，要求括号的顺序是一样的，有左括号，相应的位置必须要有右括号。

如果还记得编译原理的话，编译器在 词法分析的过程中处理括号、花括号等这个符号的逻辑，也是使用了栈这种数据结构。

再举个例子，linux系统中，cd这个进入目录的命令我们应该再熟悉不过了。

cd a/b/c/../../

这个命令最后进入a目录，系统是如何知道进入了a目录呢 ，这就是栈的应用（其实可以出一道相应的面试题了）

所以栈在计算机领域中应用是非常广泛的。

有的同学经常会想学的这些数据结构有什么用，也开发不了什么软件，大多数同学说的软件应该都是可视化的软件例如APP、网站之类的，那都是非常上层的应用了，底层很多功能的实现都是基础的数据结构和算法。

所以数据结构与算法的应用往往隐藏在我们看不到的地方！

这里我就不过多展开了，先来看题。

进入正题

由于栈结构的特殊性，非常适合做对称匹配类的题目。

首先要弄清楚，字符串里的括号不匹配有几种情况。

一些同学，在面试中看到这种题目上来就开始写代码，然后就越写越乱。

建议在写代码之前要分析好有哪几种不匹配的情况，如果不在动手之前分析好，写出的代码也会有很多问题。

先来分析一下 这里有三种不匹配的情况，

  1. 第一种情况，字符串里左方向的括号多余了 ，所以不匹配。
    括号匹配1

  2. 第二种情况，括号没有多余，但是 括号的类型没有匹配上。
    括号匹配2

  3. 第三种情况，字符串里右方向的括号多余了，所以不匹配。
    括号匹配3

我们的代码只要覆盖了这三种不匹配的情况，就不会出问题，可以看出 动手之前分析好题目的重要性。

动画如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XpVNRw0f-1687051458537)(https://code-thinking.cdn.bcebos.com/gifs/20.有效括号.gif)]

第一种情况：已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false

第二种情况：遍历字符串匹配的过程中，发现栈里没有要匹配的字符。所以return false

第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号return false

那么什么时候说明左括号和右括号全都匹配了呢，就是字符串遍历完之后，栈是空的，就说明全都匹配了。

分析完之后，代码其实就比较好写了，

但还有一些技巧，在匹配左括号的时候，右括号先入栈，就只需要比较当前元素和栈顶相不相等就可以了，比左括号先入栈代码实现要简单的多了！

实现C++代码如下：

class Solution {
public:
    bool isValid(string s) {
        if (s.size() % 2 != 0) return false; // 如果s的长度为奇数，一定不符合要求
        stack<char> st;
        for (int i = 0; i < s.size(); i++) {
            if (s[i] == '(') st.push(')');
            else if (s[i] == '{') st.push('}');
            else if (s[i] == '[') st.push(']');
            // 第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号 return false
            // 第二种情况：遍历字符串匹配的过程中，发现栈里没有我们要匹配的字符。所以return false
            else if (st.empty() || st.top() != s[i]) return false;
            else st.pop(); // st.top() 与 s[i]相等，栈弹出元素
        }
        // 第一种情况：此时我们已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false，否则就return true
        return st.empty();
    }
};

技巧性的东西没有固定的学习方法，还是要多看多练，自己灵活运用了。

其他语言版本

Java：

class Solution {
    public boolean isValid(String s) {
        Deque<Character> deque = new LinkedList<>();
        char ch;
        for (int i = 0; i < s.length(); i++) {
            ch = s.charAt(i);
            //碰到左括号，就把相应的右括号入栈
            if (ch == '(') {
                deque.push(')');
            }else if (ch == '{') {
                deque.push('}');
            }else if (ch == '[') {
                deque.push(']');
            } else if (deque.isEmpty() || deque.peek() != ch) {
                return false;
            }else {//如果是右括号判断是否和栈顶元素匹配
                deque.pop();
            }
        }
        //最后判断栈中元素是否匹配
        return deque.isEmpty();
    }
}

Python：

# 方法一，仅使用栈，更省空间
class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        
        for item in s:
            if item == '(':
                stack.append(')')
            elif item == '[':
                stack.append(']')
            elif item == '{':
                stack.append('}')
            elif not stack or stack[-1] != item:
                return False
            else:
                stack.pop()
        
        return True if not stack else False

# 方法二，使用字典
class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        mapping = {
            '(': ')',
            '[': ']',
            '{': '}'
        }
        for item in s:
            if item in mapping.keys():
                stack.append(mapping[item])
            elif not stack or stack[-1] != item: 
                return False
            else: 
                stack.pop()
        return True if not stack else False

Go：

func isValid(s string) bool {
    hash := map[byte]byte{')':'(', ']':'[', '}':'{'}
    stack := make([]byte, 0)
    if s == "" {
        return true
    }

    for i := 0; i < len(s); i++ {
        if s[i] == '(' || s[i] == '[' || s[i] == '{' {
            stack = append(stack, s[i])
        } else if len(stack) > 0 && stack[len(stack)-1] == hash[s[i]] {
            stack = stack[:len(stack)-1]
        } else {
            return false
        }
    }
    return len(stack) == 0
}

Ruby:

def is_valid(strs)
    symbol_map = {')' => '(', '}' => '{', ']' => '['}
    stack = []
    strs.size.times {|i|
        c = strs[i]
        if symbol_map.has_key?(c)
            top_e = stack.shift
            return false if symbol_map[c] != top_e
        else
            stack.unshift(c)
        end
    }
    stack.empty?
end

Javascript:

var isValid = function (s) {
  const stack = [];
  for (let i = 0; i < s.length; i++) {
    let c = s[i];
    switch (c) {
      case '(':
        stack.push(')');
        break;
      case '[':
        stack.push(']');
        break;
      case '{':
        stack.push('}');
        break;
      default:
        if (c !== stack.pop()) {
          return false;
        }
    }
  }
  return stack.length === 0;
};
// 简化版本
var isValid = function(s) {
    const stack = [], 
        map = {
            "(":")",
            "{":"}",
            "[":"]"
        };
    for(const x of s) {
        if(x in map) {
            stack.push(x);
            continue;
        };
        if(map[stack.pop()] !== x) return false;
    }
    return !stack.length;
};

TypeScript:

版本一：普通版

function isValid(s: string): boolean {
    let helperStack: string[] = [];
    for (let i = 0, length = s.length; i < length; i++) {
        let x: string = s[i];
        switch (x) {
            case '(':
                helperStack.push(')');
                break;
            case '[':
                helperStack.push(']');
                break;
            case '{':
                helperStack.push('}');
                break;
            default:
                if (helperStack.pop() !== x) return false;
                break;
        }
    }
    return helperStack.length === 0;
};

版本二：优化版

function isValid(s: string): boolean {
    type BracketMap = {
        [index: string]: string;
    }
    let helperStack: string[] = [];
    let bracketMap: BracketMap = {
        '(': ')',
        '[': ']',
        '{': '}'
    }
    for (let i of s) {
        if (bracketMap.hasOwnProperty(i)) {
            helperStack.push(bracketMap[i]);
        } else if (i !== helperStack.pop()) {
            return false;
        }
    }
    return helperStack.length === 0;
};

Swift

func isValid(_ s: String) -> Bool {
    var stack = [String.Element]()
    for ch in s {
        if ch == "(" {
            stack.append(")")
        } else if ch == "{" {
            stack.append("}")
        } else if ch == "[" {
            stack.append("]")
        } else {
            let top = stack.last
            if ch == top {
                stack.removeLast()
            } else {
                return false
            }
        }
    }
    return stack.isEmpty
}

C:

//辅助函数：判断栈顶元素与输入的括号是否为一对。若不是，则返回False
int notMatch(char par, char* stack, int stackTop) {
    switch(par) {
        case ']':
            return stack[stackTop - 1] != '[';
        case ')':
            return stack[stackTop - 1] != '(';
        case '}':
            return stack[stackTop - 1] != '{';
    }
    return 0;
}

bool isValid(char * s){
    int strLen = strlen(s);
    //开辟栈空间
    char stack[5000];
    int stackTop = 0;

    //遍历字符串
    int i;
    for(i = 0; i < strLen; i++) {
        //取出当前下标所对应字符
        char tempChar = s[i];
        //若当前字符为左括号，则入栈
        if(tempChar == '(' || tempChar == '[' || tempChar == '{')
            stack[stackTop++] = tempChar;
        //若当前字符为右括号，且栈中无元素或右括号与栈顶元素不符，返回False
        else if(stackTop == 0 || notMatch(tempChar, stack, stackTop))
            return 0;
        //当前字符与栈顶元素为一对括号，将栈顶元素出栈
        else
            stackTop--;
    }
    //若栈中有元素，返回False。若没有元素（stackTop为0），返回True
    return !stackTop;
}

C#:

public class Solution {
    public bool IsValid(string s) {
        var len = s.Length;
        if(len % 2 == 1) return false; // 字符串长度为单数，直接返回 false
        // 初始化栈
        var stack = new Stack<char>();
        // 遍历字符串
        for(int i = 0; i < len; i++){
            // 当字符串为左括号时，进栈对应的右括号
            if(s[i] == '('){
                stack.Push(')');
            }else if(s[i] == '['){
                stack.Push(']');
            }else if(s[i] == '{'){
                stack.Push('}');
            }
            // 当字符串为右括号时，当栈为空（无左括号） 或者 出栈字符不是当前的字符
            else if(stack.Count == 0 || stack.Pop() != s[i])
                return false;
        }
        // 如果栈不为空，例如“((()”，右括号少于左括号，返回false
        if (stack.Count > 0)
            return false;
        // 上面的校验都满足，则返回true
        else
            return true;
    }
}

PHP:

// https://www.php.net/manual/zh/class.splstack.php
class Solution
{
    function isValid($s){
        $stack = new SplStack();
        for ($i = 0; $i < strlen($s); $i++) {
            if ($s[$i] == "(") {
                $stack->push(')');
            } else if ($s[$i] == "{") {
                $stack->push('}');
            } else if ($s[$i] == "[") {
                $stack->push(']');
            // 2、遍历匹配过程中，发现栈内没有要匹配的字符 return false
            // 3、遍历匹配过程中，栈已为空，没有匹配的字符了，说明右括号没有找到对应的左括号 return false
            } else if ($stack->isEmpty() || $stack->top() != $s[$i]) {
                return false;
            } else {//$stack->top() == $s[$i]
                $stack->pop();
            }
        }
        // 1、遍历完，但是栈不为空,说明有相应的括号没有被匹配,return false
        return $stack->isEmpty();
    }
}

Scala:

object Solution {
  import scala.collection.mutable
  def isValid(s: String): Boolean = {
    if(s.length % 2 != 0) return false    // 如果字符串长度是奇数直接返回false
    val stack = mutable.Stack[Char]()
    // 循环遍历字符串
    for (i <- s.indices) {
      val c = s(i)
      if (c == '(' || c == '[' || c == '{') stack.push(c)
      else if(stack.isEmpty) return false   // 如果没有(、[、{则直接返回false
      // 以下三种情况，不满足则直接返回false        
      else if(c==')' && stack.pop() != '(') return false 
      else if(c==']' && stack.pop() != '[') return false 
      else if(c=='}' && stack.pop() != '{') return false 
    }
    // 如果为空则正确匹配，否则还有余孽就不匹配
    stack.isEmpty
  }
}

rust:

impl Solution {
    pub fn is_valid(s: String) -> bool {
        if s.len() % 2 == 1 {
            return false;
        }
        let mut stack = vec![];
        let mut chars: Vec<char> = s.chars().collect();
        while let Some(s) = chars.pop() {
            match s {
                ')' => stack.push('('),
                ']' => stack.push('['),
                '}' => stack.push('{'),
                _ => {
                    if stack.is_empty() || stack.pop().unwrap() != s {
                        return false;
                    }
                }
            }
        }
        stack.is_empty()
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/658586.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【Python 随练】打印楼梯与笑脸

【Python 随练】打印楼梯与笑脸

题目&#xff1a; 打印楼梯&#xff0c;并在楼梯上方打印两个笑脸 简介&#xff1a; 在本篇博客中&#xff0c;我们将使用 Python 代码打印一个楼梯&#xff0c;并在楼梯上方打印两个笑脸。我们将给出问题的解析&#xff0c;并提供一个完整的代码示例来实现这个效果。 问题…
阅读更多...
多目标优化算法：多目标浣熊优化算法（multi-objective Coati Optimization Algorithm，MOCOA）

多目标优化算法：多目标浣熊优化算法（multi-objective Coati Optimization Algorithm，MOCOA）

一、浣熊优化算法COA 浣熊优化算法&#xff08;Coati Optimization Algorithm&#xff0c;COA&#xff09;由Dehghani Mohammad等人于2022年提出的模拟浣熊狩猎行为的优化算法&#xff0c;该算法具有进化能力强&#xff0c;收敛速度快&#xff0c;收敛精度高等特点。 COA具体…
阅读更多...
【算法与数据结构】454、LeetCode 四数相加 II

【算法与数据结构】454、LeetCode 四数相加 II

文章目录 一、题目二、解法三、完整代码 所有的LeetCode题解索引&#xff0c;可以看这篇文章——【算法和数据结构】LeetCode题解。 一、题目 二、解法 思路分析&#xff1a;这道题不仅要计算元素的和为0&#xff0c;还要计算元素和为零出现的次数&#xff0c;说明这道题map比较…
阅读更多...
【Python 随练】输出国际象棋棋盘

【Python 随练】输出国际象棋棋盘

题目&#xff1a; 输出国际象棋棋盘 简介&#xff1a; 在本篇博客中&#xff0c;我们将使用 Python 代码输出国际象棋棋盘。国际象棋棋盘是一个8x8的方格矩阵&#xff0c;交替使用黑色和白色方格。我们将给出问题的解析&#xff0c;并提供一个完整的代码示例来生成这个棋盘。…
阅读更多...
C语言之指针详解（1）

C语言之指针详解（1）

目录 本章重点 1. 字符指针 2. 数组指针 3. 指针数组 4. 数组传参和指针传参 5. 函数指针 6. 函数指针数组 7. 指向函数指针数组的指针 8. 回调函数 9. 指针和数组面试题的解析 大家对比前面C语言之指针初阶来看&#xff0c;指针进阶明显看起来难度大了很多&#xff…
阅读更多...
TLS协议详解，一文带你了解TLS协议

TLS协议详解，一文带你了解TLS协议

前言 TLS&#xff08;Transport Layer Security&#xff09;是一种安全协议&#xff0c;用于保护网络通信的安全性和隐私性。它是SSL&#xff08;Secure Sockets Layer&#xff09;的后继者&#xff0c;用于在互联网上建立安全的通信连接。本文将介绍TLS的概论、工作原理、发展…
阅读更多...
计算机网络——物理层-数据通信的基础知识

计算机网络——物理层-数据通信的基础知识

物理层的基本概念 在计算机网络中&#xff0c;物理层是网络协议栈中的第一层&#xff0c;负责处理网络中传输数据的物理介质和信号传输的细节。它定义了传输数据的电气、光学和机械特性&#xff0c;以及物理连接的规范和接口标准。 物理层的主要任务是将比特流&#xff08;0和…
阅读更多...
C++之AVL树

C++之AVL树

目录 一.介绍二.简单实现AVL树1. 基本框架2. 插入结点(Insert)a. 更新平衡因子b. 左单旋c. 右单旋d. 左右双旋e. 右左双旋 3. 删除节点(Erase)a. 更新平衡因子b. 旋转c. 代码 4. 测试 一.介绍 作为对二叉搜索树的优化版本。AVL树是由俄罗斯的两位数学家G.M.Adelson-Velskii和E.…
阅读更多...
Python 3 基本语法与基本数据类型 | 菜鸟教程（二）

Python 3 基本语法与基本数据类型 | 菜鸟教程（二）

目录 一、Python3 基础语法 &#xff08;一&#xff09;编码 &#xff08;二&#xff09;标识符 &#xff08;三&#xff09;python保留字 &#xff08;四&#xff09;注释 ​&#xff08;五&#xff09;行与缩进 &#xff08;六&#xff09;多行语句 &#xff08;七&am…
阅读更多...
操作系统复习笔记3

操作系统复习笔记3

1、条件变量和互斥锁 条件变量一般和互斥锁一起使用&#xff0c;来弥补互斥锁的不足。总得来说&#xff0c;互斥锁用来规范线程对共享数据的竞争使用&#xff0c;条件变量用来协调各个线程合作完成任务。 2、enum枚举类型 enum typeName { valueName1, valueName2, valueName3…
阅读更多...
Workerman在线客服系统源码 附搭建文档

Workerman在线客服系统源码 附搭建文档

Workerman在线客服系统源码 模块化开发 强大的一键生成功能极速简化你的开发流程&#xff0c;加快你的项目开发 响应式布局 自动适配&#xff0c;无需要担心兼容性问题 完善的权限管理 自由分配子级权限、一个管理员司同时属于多个组别 通用的会员和API模块 共用同一账…
阅读更多...
【MySQL多表查询】：让你的数据检索更高效

【MySQL多表查询】：让你的数据检索更高效

前言 ✨欢迎来到小K的MySQL专栏&#xff0c;本节将为大家带来MySQL中多表查询相关知识的讲解 目录 前言一、多表关系二、多表查询1、交叉连接2、内连接3、外连接 三、集合运算四、七种JOINS实现五、多表查询练习六、总结 一、多表关系 ✨项目开发中&#xff0c;在进行数据库表结…
阅读更多...
6月人工智能论文推荐

6月人工智能论文推荐

Prompt Space Optimizing Few-shot Reasoning Success with Large Language Models https://arxiv.org/abs/2306.03799 Prompt engineering 是通过提供明确和具体的指令来增强大型语言模型(llm)能力的基本技术。它使LLM能够在各种任务中脱颖而出&#xff0c;例如算术推理、问…
阅读更多...
列表、表格、表单

列表、表格、表单

day02&#xff1a;列表、表格、表单 目标&#xff1a;掌握嵌套关系标签的写法&#xff0c;使用列表标签布局网页 01-列表 作用&#xff1a;布局内容排列整齐的区域。 列表分类&#xff1a;无序列表、有序列表、定义列表。 无序列表 作用&#xff1a;布局排列整齐的不需要规…
阅读更多...
Bean 的生命周期

Bean 的生命周期

观前提示:本篇博客演示使用的 IDEA 版本为2021.3.3版本,使用的是Java8(又名jdk1.8) 电脑使用的操作系统版本为 Windows 10 目录 Spring 的执行流程 1. 启动容器 2. 根据配置完成 Bean 的初始化 3. 注册 Bean 对象到容器中 4. 装配 Bean 的属性 Bean 的生命周期 Bean 的…
阅读更多...
掌握Python的X篇_2_Python的安装

掌握Python的X篇_2_Python的安装

掌握Python的X篇_2_Python的安装 1. 软件安装包下载1.1 Python版本的区别1.2 同一版本不同安装包的区别 2. 安装过程3. 验证是否安装成功 1. 软件安装包下载 下载地址&#xff1a;https://www.python.org/downloads/ 可以看到最新版本和历史版本 1.1 Python版本的区别 就像…
阅读更多...
express的使用(五) 简单的使用mongodb

express的使用(五) 简单的使用mongodb

原文链接 express的使用(五) 简单的使用mongodb 不要脸的求关注&#xff0c;希望能让大家批评我的不足点&#xff0c;一键三连最好了 看前提示 本篇主要描述关于express中使用mongodb以及mongodb的简单介绍还有初步使用&#xff0c;不涉及任何常用的语法&#xff0c;不建议有…
阅读更多...
算法刷题-双指针-反转链表

算法刷题-双指针-反转链表

反转链表的写法很简单&#xff0c;一些同学甚至可以背下来但过一阵就忘了该咋写&#xff0c;主要是因为没有理解真正的反转过程。 206.反转链表 力扣题目链接 题意&#xff1a;反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2-…
阅读更多...
AMD CPU微架构分析

AMD CPU微架构分析

一、SoC架构 1.1 整体架构 Zeppelin 参考链接&#xff1a;wikichip: Zeppelin 通过infinity fabric总线将单die分成多die的SoC架构&#xff0c;每个Die包含两个CPU核&#xff08;CCX&#xff09;、2各DDR通道、USB、低功耗IO以及多个IFOP和IFIS serdes接口。 如下所述中&…
阅读更多...
干翻Mybatis源码系列之第十篇：Mybatis Plugins基本概念与拦截概述

干翻Mybatis源码系列之第十篇：Mybatis Plugins基本概念与拦截概述

给自己的每日一句 不从恶人的计谋&#xff0c;不站罪人的道路&#xff0c;不坐亵慢人的座位&#xff0c;惟喜爱耶和华的律法&#xff0c;昼夜思想&#xff0c;这人便为有福&#xff01;他要像一棵树栽在溪水旁&#xff0c;按时候结果子&#xff0c;叶子也不枯干。凡他所做的尽…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023