数据结构与算法(Python)

快一年没用python了…

1. 快速排序

from typing import List


def partition(nums: List[int], low: int, high: int) -> int:
    t = nums[low]
    while low < high:
        while low < high and t <= nums[high]:
            high -= 1
        nums[low] = nums[high]
        while low < high and t >= nums[low]:
            low += 1
        nums[high] = nums[low]
    nums[low] = t
    return low


def quickSort(nums: List[int], low: int, high: int):
    if low < high:
        pivot = partition(nums, low, high)
        quickSort(nums, low, pivot - 1)
        quickSort(nums, pivot + 1, high)


if __name__ == "__main__":
    nums = list(map(int, input().split(" ")))
    print(nums)
    quickSort(nums, 0, len(nums) - 1)
    print(nums)

2. 二叉搜索树

class TreeNode:
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

    def inOrder(self):
        t = self
        stack = []
        while t is not None or len(stack) > 0:
            if t is not None:
                stack.append(t)
                t = t.left
            else:
                t = stack.pop()
                print(t.val, end=' ')
                t = t.right

def createBinarySearchTree(t: TreeNode, val: int) -> TreeNode:
    if t is None:
        t = TreeNode(val)
        return t
    if val < t.val:
        t.left = createBinarySearchTree(t.left, val)
    elif val > t.val:
        t.right = createBinarySearchTree(t.right, val)
    return t


if __name__ == "__main__":
    t = None
    for n in list(map(int, input().split(" "))):
        t = createBinarySearchTree(t, n)
    if t is not None:
        t.inOrder()

3. 最小公倍数

def gcd(x:int,y:int)->int:
    if y==0:
        return x
    return gcd(y,x%y)

def lowestCommonMultiple(a:int,b:int)->int:
    return a*b//gcd(a,b)

if __name__ == "__main__":
    while True:
        try:
            a, b = list(map(int, input().split(" ")))
            print(gcd(a, b), lowestCommonMultiple(a, b))
        except Exception as e:
            print(e)
            break

4. 质因数分解

import typing

def primeFactorization(n: int) -> typing.List[int]:
    res = []
    i = 2
    while n>1:
        while n % i == 0:
            n /= i
            res.append(i)
        i += 1
    return res

if __name__ == "__main__":
    while True:
        try:
            num = int(input())
            print(primeFactorization(num))
        except Exception as e:
            print(e)
            break

5. 二分图-匈牙利算法

from typing import (
    List,
)

class Solution:

    def maximum_groups(self, grid: List[List[int]]) -> int:
        m, n = len(grid), len(grid[0])
        res = 0
        p = [-1 for i in range(n)]
        for i in range(m):
            vis = [False for j in range(n)]
            if self.findForBoy(grid, p, i, vis):
                res += 1
        return res

    def findForBoy(self, grid: List[List[int]], p: List[int], boy: int, vis: List[bool]) -> bool:
        n = len(grid[boy])
        for j in range(n):
            if not vis[j] and grid[boy][j]:
                vis[j] = True
                if p[j] == -1 or self.findForBoy(grid, p, p[j], vis):
                    p[j] = boy
                    return True
        return False

6. 素数筛

7. 字典树

8. 单调队列

9. 单调栈

10. 树状数组

11. 差分数组

class Solution:
    def corpFlightBookings(self, bookings: List[List[int]], n: int) -> List[int]:
        res = [0 for i in range(n)]
        diff = [0 for i in range(n)]
        for booking in bookings:
            x, y, increment = booking
            x -= 1
            y -= 1
            diff[x] += increment
            if y + 1 < n:
                diff[y + 1] -= increment
        for i in range(n):
            if i == 0:
                res[i] = diff[i]
            else:
                res[i] = res[i - 1] + diff[i]
        return res

12. 第k大的元素

from typing import List

def partition(nums: List[int], low: int, high: int) -> int:
    t = nums[low]
    while low < high:
        while low < high and t <= nums[high]:
            high -= 1
        nums[low] = nums[high]
        while low < high and t >= nums[low]:
            low += 1
        nums[high] = nums[low]
    nums[low] = t
    return low

def quickSort(k: int, nums: List[int], low: int, high: int, ok: List[bool]) -> None:
    if ok[0]:
        return
    if low < high:
        pivot = partition(nums, low, high)
        if pivot == k:
            ok[0] = True
            return
        if pivot > k:
            quickSort(k, nums, low, pivot - 1, ok)
        else:
            quickSort(k, nums, pivot + 1, high, ok)

class Solution:
    def kth_largest_element(self, k: int, nums: List[int]) -> int:
        ok = [False]
        quickSort(len(nums) - k, nums, 0, len(nums) - 1, ok)
        return nums[len(nums) - k]

if __name__ == "__main__":
    s = Solution()
    print(s.kth_largest_element(1, [1, 3, 4, 2]))
    print(s.kth_largest_element(4, [2, 5, 6, 3]))
    print(s.kth_largest_element(1, [4, 3, 2, 1]))
    print(s.kth_largest_element(3, [6, 6, 7, 3, 2, 1, 10]))

13. 开平方根（舍去小数）

class Solution:
    def mySqrt(self, x: int) -> int:
        low, high = 0, x
        while low <= high:
            mid = (low + high) // 2
            if mid * mid <= x:
                low = mid + 1
            else:
                high = mid - 1
        return low - 1

14. 二叉树的中序遍历(左中右)

def inOrder(t: TreeNode) -> List[int]:
    q = []
    res = []
    while len(q) > 0 or t is not None:
        if t is not None:
            q.append(t)
            t = t.left
        else:
            t = q.pop()
            res.append(t.val)
            t = t.right
    return res

15. 组合数

class Solution:

    res = []

    def combine(self, n: int, k: int) -> List[List[int]]:
        Solution.res = []
        self.dfs(1, n, k, [])
        return Solution.res

    def dfs(self, i: int, n: int, k: int, temp: List[int]):
        if i > n or len(temp) >= k:
            if len(temp) == k:
                Solution.res.append(temp.copy())
            return

        self.dfs(i + 1, n, k, temp)		# 不添加，直接略过

        temp.append(i)		# 添加
        self.dfs(i + 1, n, k, temp)
        temp.pop()			# 回溯

16. 全排列

class Solution:
    res: List[List[int]]

    def permute(self, nums: List[int]) -> List[List[int]]:
        Solution.res = []
        n = len(nums)
        vis = [False for i in range(n)]
        self.dfs(nums, vis, [])
        return Solution.res

    def dfs(self, nums: List[int], vis: List[bool], temp: List[int]) -> None:
        if len(temp) == len(nums):
            Solution.res.append(temp.copy())
            return
        for i in range(0, len(nums)):
            if not vis[i]:
                vis[i] = True
                temp.append(nums[i])

                self.dfs(nums, vis, temp)

                temp.pop()
                vis[i] = False