leetcode_day01

任务一：有效的括号

题目链接：https://leetcode-cn.com/problems/valid-parentheses/

自己的答案：

class Solution:
    def isValid(self, s):
        s = list(s)
        length = len(s)
        
        #空字符串被认为是有效字符串
        if length == 0:
            return True
        
        stringList = ['(', ')', '[', ']', '{', '}']
        for s_element in s:
            if  s_element not in stringList:
                return False
        
        counter1 = 0
        counter2 = 0
        counter3 = 0
        for s_ele in s:
            if s_ele == "(":
                counter1 += 1
            elif s_ele == ")":
                counter1 -= 1
            elif s_ele == "[":
                counter2 += 1
            elif s_ele == "]":
                counter2 -= 1
            elif s_ele == "{":
                counter3 += 1
            elif s_ele == "}":
                counter3 -= 1
        if counter1 == 0 and counter2 == 0 and counter3 == 0:
            return True
        else:
            return False
        

官方答案：

class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """

        # The stack to keep track of opening brackets.
        stack = []

        # Hash map for keeping track of mappings. This keeps the code very clean.
        # Also makes adding more types of parenthesis easier
        mapping = {")": "(", "}": "{", "]": "["}

        # For every bracket in the expression.
        for char in s:

            # If the character is an closing bracket
            if char in mapping:

                # Pop the topmost element from the stack, if it is non empty
                # Otherwise assign a dummy value of '#' to the top_element variable
                top_element = stack.pop() if stack else '#'

                # The mapping for the opening bracket in our hash and the top
                # element of the stack don't match, return False
                if mapping[char] != top_element:
                    return False
            else:
                # We have an opening bracket, simply push it onto the stack.
                stack.append(char)

        # In the end, if the stack is empty, then we have a valid expression.
        # The stack won't be empty for cases like ((()
        return not stack