刷题记录-day6 （对称的二叉树、用两个栈实现队列、包含min函数的栈、翻转单词序列）

1.对称的二叉树

class Solution:
    def isSymmetrical(self , pRoot: TreeNode) -> bool:
        # write code here
        # 利用递归方法，构建新函数
        # 这个函数负责判断给定两个子树是否对称，先对比val是否对称
        # 然后再对比左子树的左子树与右子树的右子树，左子树的右子树和右子树的左子树是否对称
        if not pRoot:
            return True
        return self.pan(pRoot.left,pRoot.right)
        
    def pan(self,left_,right_):
        if not left_ and not right_:
            return True
        if (left_ and not right_) or (not left_ and right_):
            return False
        if left_.val != right_.val:
            return False
        return self.pan(left_.left,right_.right) and self.pan(left_.right,right_.left) 

2.用两个栈实现队列

# 利用栈的后进先出原理，使用append加在后面，使用pop弹出尾部元素
# 将stack1用于存储所有当前push的内容，然后需要pop时使用stack2进行pop
# 当stack2为空时，把stack1的内容倒序加入stack2（使用pop）
class Solution:
    def __init__(self):
        self.stack1 = []
        self.stack2 = []
    def push(self, node):
        # write code here
        self.stack1.append(node)
    def pop(self):
        if self.stack2 == []:
            while self.stack1:
                self.stack2.append(self.stack1.pop())
        return self.stack2.pop()
    
    
# 最开始写的是把stack1和stack2当成数组的，没有使用它的pop功能，所以不符合题意，但可以完成这个任务
class Solution:
    def __init__(self):
        self.stack1 = []
        self.stack2 = []
    def push(self, node):
        # write code here
        self.stack1.append(node)
        self.stack2 = self.stack1[1:]
    def pop(self):
        temp = self.stack1[0]
        self.stack1 = self.stack2
        self.stack2 = self.stack1[1:]
        return temp

3.包含min函数的栈

# 只维护一个栈，但是栈里的元素为元组（node，当前的最小值）
class Solution:
    def __init__(self):
        self.stack = []
    def push(self, node):
        # write code here
        if not self.stack:
            self.stack.append((node,node))
        else:
            min_num = node if node < self.stack[-1][1] else self.stack[-1][1]
            self.stack.append((node,min_num))
    def pop(self):
        # write code here
        self.stack.pop()
    def top(self):
        # write code here
        return self.stack[-1][0]
    def min(self):
        # write code here
        return self.stack[-1][1]
    
# 同时维护两个栈，一个负责普通压入推出，一个负责保存对应时刻的最小值
class Solution:
    def __init__(self):
        self.stack = []
        self.stack_min = []
    def push(self, node):
        # write code here
        self.stack.append(node)
        if self.stack_min == []:
            self.stack_min.append(node)
        if node < self.stack_min[-1]:
            self.stack_min.append(node)
        elif node >= self.stack_min[-1]:
            self.stack_min.append(self.stack_min[-1])
    def pop(self):
        # write code here
        self.stack.pop()
        self.stack_min.pop()
    def top(self):
        # write code here
        return self.stack[-1]
    def min(self):
        # write code here
        return self.stack_min[-1]

4.翻转单词序列

class Solution:
    def ReverseSentence(self , str: str) -> str:
        # write code here
        # 更简单的写法
        return " ".join(str.split()[::-1])
        
        # 直接把str按空格切分成list，然后将这个list翻转，最后再从list转回str
        str_list = str.split()
        str_list = str_list[::-1]
        result = " ".join(str_list)
        return result