数据结构与算法：栈+队列+递归

class SStack():
    def __init__(self):
        self._elems = []
    def is_empty(self):
        return self._elems == []
    def top(self):
        if self._elems == []:
            raise StackUnderflow("in SStack.top()")
        return self._elems[-1]
    def push(self, elem):
        self._elems.append(elem)
    def pop(self):
        if self._elems == []:
            raise StackUnderflow("in SStack.pop()")
        return self._elems.pop()
class StackUnderflow(ValueError):
    pass

#表头作为栈顶，表尾作为栈底
class LStack():
    def __init__(self):
        self._top = None
    def is_empty(self):
        return self._top is None
    def top(self):
        if self._top == []:
            raise StackUnderflow("in LStack.top()")
        return self._top.elem
    def push(self, elem):
        self._top = LNode(elem, self._top)
    def pop(self):
        if self._top is None:
            raise StackUnderflow("in LStack.pop()")
        p =self._top
        self._top = p.next
        return p.elem
class StackUnderflow(ValueError):
    pass

class Solution:
    def isValid(self, s: str) -> bool:
        stack=[]
        dic={‘[‘:‘]‘,‘{‘:‘}‘,‘(‘:‘)‘}
        for parenthese in s:
            if parenthese in dic:
                stack.append(parenthese)
            elif stack==[] or parenthese != dic[stack.pop()]:
                return False
        return stack==[]

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        #先找到所有可以匹配的索引号,然后找出最长连续数列
        if not s:
            return 0
        res = []
        stack = []
        for i in range(len(s)):
            if stack and s[i] == ")":
                res.append(stack.pop())
                res.append(i)
            if s[i] == "(":
                stack.append(i)
        res.sort()
        #print(res)
        i = 0
        ans = 0
        n = len(res)
        while i < n:
            j = i
            while j < n - 1 and res[j + 1] == res[j] + 1:
                j += 1
            ans = max(ans, j - i + 1)
            i = j + 1
        return ans

class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        f1 = lambda a,b:a+b
        f2 = lambda a,b:a-b
        f3 = lambda a,b:a*b
        f4 = lambda a,b:int(a/b)
        dic = {‘+‘:f1,‘-‘:f2,‘*‘:f3,‘/‘:f4}
        stack = []
        for i in tokens:
            if i in dic:
                a = stack.pop()
                b = stack.pop()
                stack.append(dic[i](b,a))
            else:
                i = int(i)
                stack.append(i)
        return stack[-1]

class MyCircularDeque:

    def __init__(self, k: int):
        """
        Initialize your data structure here. Set the size of the deque to be k.
        """
        self.queue=[]
        self.size=k

    def insertFront(self, value: int) -> bool:
        """
        Adds an item at the front of Deque. Return true if the operation is successful.
        """
        if not self.isFull():
            self.queue.insert(0,value)
            return True
        else:
            return False

    def insertLast(self, value: int) -> bool:
        """
        Adds an item at the rear of Deque. Return true if the operation is successful.
        """
        if not self.isFull():
            self.queue.append(value)
            return True
        else:
            return False

    def deleteFront(self) -> bool:
        """
        Deletes an item from the front of Deque. Return true if the operation is successful.
        """
        if not self.isEmpty():
            self.queue.pop(0)
            return True
        else:
            return False

    def deleteLast(self) -> bool:
        """
        Deletes an item from the rear of Deque. Return true if the operation is successful.
        """
        if not self.isEmpty():
            self.queue.pop()
            return True
        else:
            return False

    def getFront(self) -> int:
        """
        Get the front item from the deque.
        """
        if self.isEmpty():
            return -1
        else:
            return self.queue[0]

    def getRear(self) -> int:
        """
        Get the last item from the deque.
        """
        if self.isEmpty():
            return -1
        else:
            return self.queue[-1]

    def isEmpty(self) -> bool:
        """
        Checks whether the circular deque is empty or not.
        """
        return len(self.queue) == 0

    def isFull(self) -> bool:
        """
        Checks whether the circular deque is full or not.
        """
        return len(self.queue) == self.size

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        ‘‘‘
        #暴力法
        if nums==[]:
            return []
        n=len(nums)
        res=[]
        for i in range(n-k+1):
            window=nums[i:i+k]
            res.append(max(window))
        return res
         if not nums or k == 0:
            return []
        if k == 1:
            return nums
        ‘‘‘
        #双端队列
        if nums == [] or k == 0:
            return []
        if k == 1:
            return nums
        #队列里保存可能是最大值的索引
        queue = [0]
        # 存放窗口中最大值
        res = []
        for i in range(1,len(nums)):
            #判断队首对应的元素是否已经滑出窗口
            if i-queue[0] >= k:
                queue.pop(0)
            #保证当前最大值的索引是第一个。遇到一个新数时，将它与队尾元素比较，如果大于队尾元素，则丢掉队尾元素，继续重复比较，直到新数小于队尾元素，或者队列为空为止，将新数下标放入队列
            while queue and nums[queue[-1]] < nums[i]:
                queue.pop()
            queue.append(i)
            if i >= k-1:
                res.append(nums[queue[0]])
        return res

def fib_recur(n):
  if n <= 1:
    return n
  return fib_recur(n-1) + fib_recur(n-2)

def fact(n):
    if n == 0:
        return 1
    else:
        return n * fact(n - 1)

def perm(l):  
    if(len(l)<=1):  
        return [l]  
    r=[]  
    for i in range(len(l)):  
        s=l[:i]+l[i+1:]  
        p=perm(s)  
        for x in p:  
            r.append(l[i:i+1]+x)  
    return r

class Solution:
    def climbStairs(self, n: int) -> int:
        ‘‘‘
        递归
        if n==1:
            return 1
        elif n==2:
            return 2
        else:
            return self.climbStairs(n-1)+self.climbStairs(n-2)
        ‘‘‘
        #动态规划
        nums=[1,1]
        for i in range(2,n+1):
            nums.append(nums[i-1]+nums[i-2])
        return nums[n]