day 9 字符串part2

LC 151. 反转字符串中的单词

在python里，思路更加简单：先用split（）函数，里面不传参数的话会默认将元素按空格分隔，不管有几个空格，都视为一个空格。然后整体反转列表中的元素，例如['I' , 'AM' , 'CAT'],我们直接交换ls[0] 和 ls[2]即可完成单词的反转。反转的方法和之前移除元素那个题一样，采用双指针。

class Solution:
    def reverseWords(self, s: str) -> str:
        ls = s.split()
        left , right = 0 , len(ls) - 1
        while left <= right:
            ls[left] , ls[right] = ls[right] , ls[left]
            left += 1
            right -= 1
        return ' '.join(ls)

卡玛网55 右旋字符串

python不能修改字符串，所以还是需要额外空间，这样一来代码又水了。。。不过还是看了下直接在字符串修改的方法。

k = int(input())
s = input()
n = len(s)
temp1 = s[n-k:]
temp2 = s[:n-k]
print(temp1 + temp2)

LC 232. 用栈实现队列

class MyQueue:

    def __init__(self):
        self.stack1 = [] # in
        self.stack2 = []

    def push(self, x: int) -> None:
        self.stack1.append(x)
        return self.stack1

    def pop(self) -> int:

        if self.empty():
            return None
        if len(self.stack2) == 0:
            
            for i in range(len(self.stack1)):
                self.stack2.append(self.stack1.pop())
            return self.stack2.pop()

        elif len(self.stack2) != 0:
            return self.stack2.pop()
            
    def peek(self) -> int:
        if len(self.stack2) != 0:
            n = len(self.stack2)
            return self.stack2[n-1]
        else:
            return self.stack1[0]

    def empty(self) -> bool:
        if len(self.stack1) == 0 and len(self.stack2) == 0:
            return True
        else:
            return False

有点没读懂题，总之就是两个列表（栈）来模拟一个队列，stack1代表队列进来元素，stack2代表队列中的元素要出队。当遇到出队操作时，先把stack1里的元素逐个从末尾开始append到stack2中（不能直接stack1.pop（0），不然就没有意义了，stack1的栈底，即0的位置，是不允许出元素的），然后再返回stack2.pop()即可。

做着题最大的障碍是不能用python里的语法直接返回元素，必须按照要求

LC 225. 用队列实现栈

class MyStack:
    def __init__(self):
        self.queue = []

    def push(self, x: int) -> None:
        self.queue.append(x)

    def pop(self) -> int:
        for i in range(len(self.queue) - 1):
            temp = self.queue.pop(0)
            self.queue.append(temp)
        return self.queue.pop(0)

    def top(self) -> int:
        return self.queue[len(self.queue) - 1]

    def empty(self) -> bool:
        return True if len(self.queue) == 0 else False

好像使用列表有点耍赖、、

LC 20. 有效的括号

本题归根结底，只有三种不匹配的情况：

1.左括号多了 2. 右括号多了 3.括号类型不匹配

class Solution:
    def isValid(self, s: str) -> bool:
        if len(s) % 2 != 0:
            return False
        stack = []
        for i in s:
            if i == '(':
                stack.append(')')
            elif i == '[':
                stack.append(']')
            elif i == '{':
                stack.append('}')
            else:
                if len(stack) != 0 and i == stack[-1]:
                    stack.pop()
                else:
                    return False #对应右括号过多或不匹配两种情况

        return True if len(stack) == 0 else False

150. 逆波兰表达式求值

本题实质上就是计算后缀表达式，使用栈的一个经典操作。

比如 1 2 + 3 4 + ×，对应的中缀表达式就是（1+2）×（3+4），利用栈存储数字，当遇到操作符的时候，取出栈顶的两个数字做对应的操作，再把操作得到的结果压入栈中，那么最终的结果就是栈的最后一个元素.

class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        op = {"+","-","*","/"}
        st = []
        for s in tokens:
            if s in op:
                if s == "+":
                    st[-2] += st[-1]
                    st.pop()
                elif s == "-":
                    st[-2] -= st[-1]
                    st.pop()
                elif s == "*":
                    st[-2] *= st[-1]
                    st.pop()
                else:
                    st[-2] = int(st[-2] / st[-1])
                    st.pop()
            else:
                st.append(int(s))
        return st[0]