[leetcode] Python(9)--最小栈(155)、有效的解答(20)、每日温度(739)、逆波兰表达式求值(150)

从零开始的力扣（第九天）~

1.最小栈

设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。

push(x) – 将元素 x 推入栈中。
pop() – 删除栈顶的元素。
top() – 获取栈顶元素。
getMin() – 检索栈中的最小元素。

示例:
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.getMin(); --> 返回 -2.
—————————————————————————————————————————

了解栈的定义，没什么难度

class MinStack(object):

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack = []
        

    def push(self, x):
        """
        :type x: int
        :rtype: None
        """
        self.stack.append(x)
        

    def pop(self):
        """
        :rtype: None
        """
        self.stack.pop()
        

    def top(self):
        """
        :rtype: int
        """
        return self.stack[-1]
        

    def getMin(self):
        """
        :rtype: int
        """
        return min(self.stack)


# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(x)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

栈与队列不同的是栈遵循后入先出原则（LIFO）。

2.有效的解答

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

有效字符串需满足：

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

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

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

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

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

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

将所有左括号加入栈中，若出现右括号，与栈最后一项比对，若相符，则二者出栈

class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        if not s:
            return True
        list = []
        list_s = [i for i in s]
        while list_s:
            if list_s[0] in "([{":
                list.append(list_s.pop(0))
                if not list_s:
                    return False
            else:
                if not list:
                    return False
                if list[-1] == "(":
                    if list_s[0] != ")":
                        return False
                elif list[-1] == "[":
                    if list_s[0] != "]":
                        return False
                else:
                    if list_s[0] != "}":
                        return False
                list_s.pop(0)
                list.pop(-1)
        return True if not list else False

大神的解法，直接把一对括号用空值replace，就是时间要长一些

class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        while '{}' in s or '()' in s or '[]' in s:
            s = s.replace('{}', '')
            s = s.replace('[]', '')
            s = s.replace('()', '')
        return s == ''
                    

3.每日温度

根据每日 气温 列表，请重新生成一个列表，对应位置的输入是你需要再等待多久温度才会升高的天数。如果之后都不会升高，请输入 0 来代替。

例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。

提示：气温 列表长度的范围是 [1, 30000]。每个气温的值的都是 [30, 100] 范围内的整数。
—————————————————————————————————————————

我最初的想法是建立二次循环，每次找到比原数大的数时返回索引，不过此方法时间复杂度很高，不可取，这里放上来做参考

class Solution(object):
    def dailyTemperatures(self, T):
        """
        :type T: List[int]
        :rtype: List[int]
        """
        l = len(T)
        list_temp = []
        for i in range(l):
            for j in range(i, l):
                if T[j] > T[i]:
                    list_temp.append(j - i)
                    break
                else:
                    if j + 1 >= l:
                        list_temp.append(0)
                        break
                    continue
        return list_temp

通过栈判断，以递减栈为基础，当前元素小于栈顶元素则入栈，当前元素大于栈顶元素则记录差值，然后移除栈顶元素

class Solution(object):
    def dailyTemperatures(self, T):
        """
        :type T: List[int]
        :rtype: List[int]
        """
        stack = list()
        t_length = len(T)
        res_list = [0 for i in range(t_length)]
        
        for key, value in enumerate(T):     
            if stack:
                while stack and T[stack[-1]] < value:
                    res_list[stack[-1]] = key - stack[-1]
                    stack.pop()
            stack.append(key)
        return res_list

4.逆波兰表达式求值

根据逆波兰表示法，求表达式的值。
有效的运算符包括 +, -, *, / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

说明：
整数除法只保留整数部分。
给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：
输入: [“2”, “1”, “+”, “3”, “*”]
输出: 9
解释: ((2 + 1) * 3) = 9

示例 2：
输入: [“4”, “13”, “5”, “/”, “+”]
输出: 6
解释: (4 + (13 / 5)) = 6

示例 3：
输入: [“10”, “6”, “9”, “3”, “+”, “-11”, “", “/”, "”, “17”, “+”, “5”, “+”]
输出: 22
解释:
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22
—————————————————————————————————————————

此题较为简单，依旧是使用栈的思路，找到符号的前两位数字进行运算，结果存入栈中

class Solution(object):
    def evalRPN(self, tokens):
        """
        :type tokens: List[str]
        :rtype: int
        """
        if len(tokens) == 1:
            return int(tokens[0])
        answer = 0
        stack = list()
        for key, value in enumerate(tokens):
            if value in "+-*/":
                if tokens[key] == "+":
                    answer = stack[-2] + stack[-1]
                if tokens[key] == "-":
                    answer = stack[-2] - stack[-1]
                if tokens[key] == "*":
                    answer = stack[-2] * stack[-1]
                if tokens[key] == "/":
                    answer = int(stack[-2] / float(stack[-1]))
                stack.pop()
                stack.pop()
                stack.append(answer)
            else: 
                stack.append(int(value))
        return answer

此题比较有意思的一点是，在python 2 的除法中使用 / 是当除数与被除数都为整数时，除法结果也是整数，不过是向下取整的整数，而当除数或被除数一个是浮点数时，结果才是浮点数，所以我float了一下，而在python 3 中 / 的结果无论除数与被除数如何结果都是浮点数。

还有一点就是stack[-2]与stack[-1]在除法中不要搞乱顺序了。

以上就是今日经验！