【LeetCode】Python3实现最长公共前缀和有效的括号

最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 “”。

示例 1:
输入: [“flower”,“flow”,“flight”]
输出: “fl”

示例 2:
输入: [“dog”,“racecar”,“car”]
输出: “”
解释: 输入不存在公共前缀。

说明：所有输入只包含小写字母 a-z 。

方法一：水平扫描法
先求出所有字符串长度最小值min_len，最长公共前缀的长度肯定小于等于min_len。对于第一个字符串的前min_len个字符，依次取出每位字符与其他所有的字符串对应位上的字符进行比较，直到出现不相等就结束。

class Solution:
    def longestCommonPrefix(self, strs):
        """
        strs: list[str]
        output: str
        """
        result = ""
        if strs == []:
            return result
        if len(strs) == 1:
            return strs[0]
    
        #先求列表中字符串长度最小值
        lens = [len(s) for s in strs]
        min_len = min(lens)
                
        for i in range(min_len):  #遍历首个字符串前min_len个字符
            for j in range(1,len(strs)):  #列表遍历
                if strs[j][i] != strs[0][i]: 
                    return result  #各个字符串第i个字符不相等，直接输出前i个字符
            result += strs[0][i]  #列表遍历完，表示各个字符串第i个字符相等，将第i个字符加入到结果中。
        return result

方法二：二分查找法（类比于数字的二分查找法）

class Solution:
    #判断第一个字符串的前lens个字符（包括第lens个）是否是所有字符串共有的
    def isCommonPrefix(self,strs,lens):
        str_com = strs[0][0:lens+1]
        for i in range(1,len(strs)):
            if strs[i][0:lens+1] != str_com:
                return False
        return True
    
    def longestCommonPrefix(self, strs):
        """
        strs: list[str]
        output: str
        """
        if strs == []:
            return ""
        if len(strs) == 1:
            return strs[0]
        
        #先求列表中字符串长度最小值
        lens = [len(s) for s in strs]
        min_len = min(lens)
        
        low = 0
        high = min_len - 1
        while low <= high:
            middle = (low + high)//2
            #判断前middle个字符是否是公共前缀
            if self.isCommonPrefix(strs,middle):
                low = middle + 1  #是，说明公共前缀不止middle长度
            else:
                high = middle - 1  #不是，说明公共前缀只是middle长度的一部分
        return strs[0][0:(low+high)//2 + 1]
        

有效的括号

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

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。

注意空字符串可被认为是有效字符串。

示例 1:
输入: “()”
输出: true

示例 2:
输入: “()[]{}”
输出: true

示例 3:
输入: “(]”
输出: false

示例 4:
输入: “([)]”
输出: false

示例 5:
输入: “{[]}”
输出: true

官方解题：
思想是有效表达式的子表达式也应该是有效表达式，如下图：

每当在表达式中遇到一对匹配的括号时，就从表达式中删除它，最后剩留下一个空字符串。

算法如下：

1. 初始化栈 S
2. 依次处理表达式的每个括号。
3. 如果遇到开括号，我们只需将其推到栈上即可。这意味着我们将稍后处理它，让我们简单地转到前面的 子表达式。
4. 如果我们遇到一个闭括号，那么我们检查栈顶的元素。如果栈顶的元素是一个 相同类型的 左括号，那么我们将它从栈中弹出并继续处理。否则，这意味着表达式无效。
5. 如果到最后我们剩下的栈中仍然有元素，那么这意味着表达式无效。

class Solution:
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        stack = []  #用于存储开括号的栈
        mapping = {")": "(", "}": "{", "]": "["}#根据闭括号映射到开括号，便于与栈顶元素进行比较
        for char in s:
            if char in mapping:  #如果char是一个闭括号
                #如果stack非空，取出stack最上面的一个元素，stack空的话给top_element赋值'#'
                top_element = stack.pop() if stack else '#'  
                #char对应的映射即char对应的开括号，与栈顶元素不等，整体就不是有效的括号，返回False
                if mapping[char] != top_element:
                    return False
            else:
                stack.append(char)  #char是开括号，直接入栈

        #for循环结束，如果栈为空表示所有括号都配对成功，是有效的括号字符串，
        #如果栈不空，表示还有的括号是单独的，就不是有效的括号字符串。
        return not stack