算法-栈与队列

1.用栈实现队列

使用栈实现队列的下列操作：

push(x) -- 将一个元素放入队列的尾部。
pop() -- 从队列首部移除元素。
peek() -- 返回队列首部的元素。
empty() -- 返回队列是否为空。

class Solution:
    def __init__(self):
        self.s1 = []
        self.s2 = []

    def push(self,x):
        self.s1.append(x)

    def pop(self):
        if self.empty():
            return None
        if self.s2:
            return self.s2.pop()
        else:
            for _ in range(len(self.s1)):
                self.s2.append(self.s1.pop())
            return self.s2.pop()

    def peek(self):
        ans = self.pop()
        self.s2.append(ans)
        return ans

    def empty(self):
        return not (self.s1 or self.s2)

a = Solution()
print(a.push(1),a.push(2),a.peek(),a.pop(),a.empty())

2.用队列实现栈

使用队列实现栈的下列操作：

• push(x) -- 元素 x 入栈
• pop() -- 移除栈顶元素
• top() -- 获取栈顶元素
• empty() -- 返回栈是否为空

import collections
class MyStack:

    def __init__(self):

        self.queue = collections.deque()

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

        n = len(self.queue)
        self.queue.append(x)
        for _ in range(n):
            self.queue.append(self.queue.popleft())

    def pop(self) -> int:

        return self.queue.popleft()

    def top(self) -> int:

        return self.queue[0]

    def empty(self) -> bool:

        return not self.queue

3.有效的括号

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

有效字符串需满足：

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

class Solution:
    def isValid(self,s):
        stack = []
        for x in s:
            if x == '(':
                stack.append(')')
            elif x == '[':
                stack.append(']')
            elif x == '{':
                stack.append('}')
            elif not stack or stack[-1] != x:
                return False
            else:
                stack.pop()
        return True if not stack else False

4.删除字符串中的所有相邻重复项

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

class Solution:
    def removeDuplicates(self,s):
        res = list()
        for item in s:
            if res and res[-1] == item:
                res.pop()
            else:
                res.append(item)
        return ''.join(res)

5.逆波兰表达式求值

根据 逆波兰表示法，求表达式的值。

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

class Solution(object):
    def evalRPN(self, tokens):
        stack = []
        for token in tokens:
            try:
                stack.append(int(token))
            except:
                num2 = stack.pop()
                num1 = stack.pop()
                stack.append(self.evaluate(num1, num2, token))
        return stack[0]

    def evaluate(self, num1, num2, op):
        if op == "+":
            return num1 + num2
        elif op == "-":
            return num1 - num2
        elif op == "*":
            return num1 * num2
        elif op == "/":
            return int(num1 / float(num2))

6.滑动窗口最大值

给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回滑动窗口中的最大值。

import collections
class Solution:
    def maxSlidingWindow(self,nums,k):
        n = len(nums)
        q = collections.deque()
        for i in range(k):
            while q and nums[i] >= nums[q[-1]]:
                q.pop()
            q.append(i)

        ans  = [nums[q[0]]]
        for i in range(k,n):
            while q and nums[i] >= nums[q[-1]]:
                q.pop()
            q.append(i)
            while q[0] <= i - k:
                q.popleft()
            ans.append(nums[q[0]])
        return ans

7.前 K 个高频元素

import collections
import heapq
class Solution:
    def topKfrequent(self,nums,k):
        # 要统计元素出现频率
        map = collections.Counter(nums)
        # 对频率排序
        # 定义一个小顶堆，大小为k
        pri_que =[]
        # 用固定大小为k的小顶堆，扫面所有频率的数值
        for key,freq in map.items():
            heapq.heappush(pri_que,(key,freq))
            # 如果堆的大小大于了K，则队列弹出，保证堆的大小一直为k
            if len(pri_que) > k:
                heapq.heappop(pri_que)
        # 找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒序来输出到数组
        res = [0] * k
        for i in range(k - 1,-1,-1):
            res[i] = heapq.heappop(pri_que)[1]
        return res