Python第七次学习例题------复杂数据结构（堆、队列、栈、链表、二叉树、有向图）

本次我们将结合上一次的学习，解决下列几题（题目来源LeetCode）真难！！！

一、复杂数据结构

1.1、堆

有一难石头,每块石头的重量都是正整数。
每一回合,从中选出两块最重的石头，然后将它们一起粉碎。假设石头的重量分别为x和y,且x <=y.那么粉碎的可能结果如下:
如果x == y,那么两块石头都会被完全粉碎;
如果x != y,那么重量为x的石头将会完全粉碎,而重量为y的石头新重量为y-x。
最后，最多只会制下一块石头。返回此石头的重量。如果没有石头刺下，就返回0。

from typing import List

import heapq  # heapq库是专门处理最小堆的库


class Solution:
    def zuihouyikuaishitoudezhongliang(self, stones: List[int]) -> int:
        stones_shuliang = [-i for i in stones]  # 用取负数的办法弯道处理最大堆问题
        heapq.heapify(stones_shuliang)  # 把list最小推结构化
        while len(stones_shuliang) > 1:
            a = heapq.heappop(stones_shuliang)  # 取出质量最大的石头
            b = heapq.heappop(stones_shuliang)  # 在剩下的石头里取出质量最大的石头
            if a < b:  # 如果第一块石头比第二块重，那么把摩擦剩下的小石头放进堆里
                heapq.heappush(stones_shuliang, a - b)  # 如果两块石头一样重，就都没有了
        if stones_shuliang:
            c = -stones_shuliang[0]  # 如果剩下石头，那么返回值是其质量
        else:
            c = 0  # 如果不剩下石头，那么返回值是0
        return c

if __name__ == '__main__':
    arr = input("")
    nums = [int(n) for n in arr.split()]
    sol = Solution()
    print(sol.zuihouyikuaishitoudezhongliang(nums))

1.2、队列

写一个RecentCount类来计算特定时间范围内最近的请求。
请实现RecentCount类：
（1）RecentCount()初始化计数器，请求数为0.
（2）int ping(int t)在时间t添加一个新请求，t表示咦毫秒为单位的某个时间，并返回过去3000毫秒内发生的多有请求数（包括新请求）。确切说，返回在[t-3000,t]内发生的请求数。
保证每次对ping的调用都使用比之前更大的t值。

class RecentCount(object):
    def __init__(self):
        self.q = collections.deque()
    def ping(self,t):
        self.q.append(t)
        while self.q[0]<t-3000:
            self.q.popleft()
        return len(self.q)

1.3、栈

有效的括号（辅助栈法）
原理：
1.栈先入后出，即若遇到左括号入栈，那么遇到右括号时栈顶左括号出栈。
2.建立哈希表dic，构建左右括号对应关系。

class Solution:
    def isValid(self, s: str) -> bool:
        dic = {'(':')','[':']','{':'}','?':'?'}#定义一个括号字典
        stack = ['?'] #定义一个栈
        for c in s:
            if c in dic:stack.append(c)
            elif dic[stack.pop()] != c:return False
        return len(stack) == 1

if __name__ == '__main__':
    s = Solution()
    print(s.isValid(input()))

1.4、链表

删除排序链表中的重复元素。（即删除重复节点。）
建立一个虚拟头节点dummy以减少边界判断，tail代表当前有效链表的结尾

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        if head == None:
            return None
        dummy = ListNode(-101)
        tail = dummy
        while head:
            if tail.val != head.val:
                tail.next = head
                tail = tail.next
            head = head.next
        tail.next = None
        return dummy.next

1.5、二叉树

BiNode

class Solution:
    def convertBiNode(self,root:TreeNode) -> TreeNode:
        self.pre = self.ans = None
        def dfs(root):
            if not root:return 
            dfs(root.left)
            root.left = None
            if self.pre:self.pre.right = root
            if self.pre is None:self.ans = root
            self.pre = root
            dfs(root.right)
        dfs(root)
        return self.ans

1.6、有向图

找到小镇的法官

class Solution:
    def findJudge(self,N,trust):
        in_degree = [0]*(N+1)
        out_degree = [0]*(N+1)
        for a,b in trust:
            in_degree[b] += 1
            out_degree[a] += 1
        for i in range(1,N+1):
            if in_degree[i] == N-1 and out_degree[i] == 0:
                return i
            return -1

呔！菜鸡在此