mlymath 0.1.0__tar.gz

mlymath-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.2
+Name: mlymath
+Version: 0.1.0
+Author: mly
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Dynamic: author
+Dynamic: classifier
+Dynamic: requires-python

mlymath-0.1.0/math/__init__.py

@@ -0,0 +1,63 @@
+from .math import (
+    sha3_256,
+    sha3_512,
+    sha256,
+    gcd,
+    lcm,
+    is_prime,
+    comb,
+    pow,
+    fib_list,
+    fib,
+    pell_list,
+    pell,
+    factor,
+    manhattan_d,
+    euclidean_d,
+    matrix_add,
+    matrix_sub,
+    matrix_mul,
+    matrix_scalar_mul,
+    matrix_transpose,
+    list_max,
+    max,
+    list_min,
+    min,
+    list_max_index,
+    max_index,
+    list_min_index,
+    min_index,
+    math_help
+)
+
+__all__ = [
+    'sha3_256',
+    'sha3_512',
+    'sha256',
+    'gcd',
+    'lcm',
+    'is_prime',
+    'comb',
+    'pow',
+    'fib_list',
+    'fib',
+    'pell_list',
+    'pell',
+    'factor',
+    'manhattan_d',
+    'euclidean_d',
+    'matrix_add',
+    'matrix_sub',
+    'matrix_mul',
+    'matrix_transpose',
+    'matrix_scalar_mul',
+    'list_max',
+    'max',
+    'list_min',
+    'min',
+    'list_max_index',
+    'max_index',
+    'list_min_index',
+    'min_index',
+    'math_help'
+]

mlymath-0.1.0/math/math.py

@@ -0,0 +1,383 @@
+import hashlib  # 新增：用于 SHA-256 加密
+
+def sha3_256(input_string: str) -> str:
+    """
+    使用 SHA3-256 算法加密字符串。
+    :param input_string: 待加密的字符串
+    :return: 加密后的十六进制字符串
+    """
+    sha3_256_hash = hashlib.sha3_256(input_string.encode()).hexdigest()
+    return sha3_256_hash
+
+def sha3_512(input_string: str) -> str:
+    """
+    使用 SHA3-512 算法加密字符串。
+    :param input_string: 待加密的字符串
+    :return: 加密后的十六进制字符串
+    """
+    sha3_512_hash = hashlib.sha3_512(input_string.encode()).hexdigest()
+    return sha3_512_hash
+
+
+def sha256(input_string: str) -> str:
+    """
+    使用 SHA-256 算法加密字符串。
+    :param input_string: 待加密的字符串
+    :return: 加密后的十六进制字符串
+    """
+    sha256_hash = hashlib.sha256(input_string.encode()).hexdigest()
+    return sha256_hash
+
+
+def gcd(*nums: int) -> int:
+    """优化后：移除冗余操作"""
+    from math import gcd as _gcd  # 模块级导入（关键）
+    current_gcd = nums[0]
+    for num in nums[1:]:
+        current_gcd = _gcd(current_gcd, num)
+        if current_gcd == 1:
+            break
+    return current_gcd  # 移除 abs（math.gcd 已返回非负数）
+
+def lcm(*nums: int) -> int:
+    """优化后：恢复 `0 in nums` 检查"""
+    if 0 in nums:  # 更高效的零检查
+        return 0
+    current_lcm = 1
+    for num in nums:
+        current_lcm = current_lcm * num // gcd(current_lcm, num)
+    return current_lcm
+
+def is_prime(n):
+    if n < 2:
+        return False
+    if n in (2, 3):
+        return True
+    if n % 2 == 0 or n % 3 == 0:
+        return False
+    i = 5
+    w = 2
+    while i * i <= n:
+        if n % i == 0:
+            return False
+        i += w
+        w = 6 - w  # 在2和4之间切换，实现步长6的检查
+    return True
+
+def comb(n: int, k: int) -> int:
+    """计算组合数 C(n, k)"""
+    if k < 0 or k > n:
+        return 0
+    if k == 0 or k == n:
+        return 1
+    # 使用动态规划优化组合数计算
+    dp = [0] * (k + 1)
+    dp[0] = 1
+    for i in range(1, n + 1):
+        for j in range(min(i, k), 0, -1):
+            dp[j] += dp[j - 1]
+    return dp[k]
+
+def pow(x, y):
+    """
+    快速计算 x 的 y 次幂。
+    :param x: 底数，可以是整数或浮点数
+    :param y: 指数，可以是正数、负数或零
+    :return: 计算结果
+    """
+    if y == 0:
+        return 1  # 任何数的0次幂为1
+    if y < 0:
+        x = 1 / x  # 处理负指数
+        y = -y
+    result = 1
+    while y > 0:
+        if y % 2 == 1:  # 如果指数为奇数
+            result *= x
+        x *= x  # 底数平方
+        y //= 2  # 指数减半
+    return result
+
+def fib_list(n: int) -> list:
+    """
+    生成包含前 N 项的斐波那契数列。
+    :param n: 数列的项数（必须为正整数）
+    :return: 包含前 N 项斐波那契数列的列表
+    """
+    if n <= 0:
+        raise ValueError("输入必须为正整数")
+    sequence = [0, 1]
+    for _ in range(2, n):
+        sequence.append(sequence[-1] + sequence[-2])
+    return sequence[:n]
+
+def fib(n: int) -> int:
+    """
+    返回第 N 项的斐波那契数。
+    :param n: 第 N 项（必须为正整数）
+    :return: 第 N 项的斐波那契数
+    """
+    if n <= 0:
+        raise ValueError("输入必须为正整数")
+    a, b = 0, 1
+    for _ in range(1, n):
+        a, b = b, a + b
+    return a
+
+def pell_list(n: int) -> list:
+    """
+    生成包含前 N 项的佩尔数列。
+    :param n: 数列的项数（必须为正整数）
+    :return: 包含前 N 项佩尔数列的列表
+    """
+    if n <= 0:
+        raise ValueError("输入必须为正整数")
+    sequence = [0, 1]
+    for _ in range(2, n):
+        sequence.append(2 * sequence[-1] + sequence[-2])
+    return sequence[:n]
+
+def pell(n: int) -> int:
+    """
+    返回第 N 项的佩尔数。
+    :param n: 第 N 项（必须为正整数）
+    :return: 第 N 项的佩尔数
+    """
+    if n <= 0:
+        raise ValueError("输入必须为正整数")
+    a, b = 0, 1
+    for _ in range(1, n):
+        a, b = b, 2 * b + a
+    return a
+
+def factor(n: int) -> list:
+    """
+    分解整数 n 的质因数。
+    :param n: 待分解的整数（必须为正整数）
+    :return: 包含所有质因数的列表
+    """
+    if n <= 0:
+        raise ValueError("输入必须为正整数")
+    factors = []
+    # 处理2的因子
+    while n % 2 == 0:
+        factors.append(2)
+        n //= 2
+    # 处理奇数因子
+    i = 3
+    while i * i <= n:
+        while n % i == 0:
+            factors.append(i)
+            n //= i
+        i += 2
+    # 如果剩余的 n 是质数
+    if n > 1:
+        factors.append(n)
+    return factors
+
+def manhattan_d(point1, point2):
+    """
+    计算两个点之间的曼哈顿距离。
+    :param point1: 第一个点的坐标 (list 或 tuple)
+    :param point2: 第二个点的坐标 (list 或 tuple)
+    :return: 曼哈顿距离
+    """
+    if len(point1) != len(point2):
+        raise ValueError("两个点的维度必须相同")
+    return sum(abs(a - b) for a, b in zip(point1, point2))
+
+def euclidean_d(point1, point2, precision=None):
+    """
+    计算两个点之间的欧几里得距离。
+    :param point1: 第一个点的坐标 (list 或 tuple)
+    :param point2: 第二个点的坐标 (list 或 tuple)
+    :param precision: 可选参数，指定结果保留的小数位数
+    :return: 欧几里得距离
+    """
+    if len(point1) != len(point2):
+        raise ValueError("两个点的维度必须相同")
+    distance = (sum((a - b) ** 2 for a, b in zip(point1, point2))) ** 0.5
+    return round(distance, precision) if precision is not None else distance
+
+def matrix_add(matrix1, matrix2):
+    """
+    计算两个矩阵的加法。
+    :param matrix1: 第一个矩阵 (二维列表)
+    :param matrix2: 第二个矩阵 (二维列表)
+    :return: 相加后的矩阵 (二维列表)
+    """
+    if len(matrix1) != len(matrix2) or any(len(row1) != len(row2) for row1, row2 in zip(matrix1, matrix2)):
+        raise ValueError("两个矩阵的维度必须相同")
+    return [[a + b for a, b in zip(row1, row2)] for row1, row2 in zip(matrix1, matrix2)]
+
+def matrix_sub(matrix1, matrix2):
+    """
+    计算两个矩阵的减法。
+    :param matrix1: 第一个矩阵 (二维列表)
+    :param matrix2: 第二个矩阵 (二维列表)
+    :return: 相减后的矩阵 (二维列表)
+    """
+    if len(matrix1) != len(matrix2) or any(len(row1) != len(row2) for row1, row2 in zip(matrix1, matrix2)):
+        raise ValueError("两个矩阵的维度必须相同")
+    return [[a - b for a, b in zip(row1, row2)] for row1, row2 in zip(matrix1, matrix2)]
+
+def matrix_mul(matrix1, matrix2):
+    """
+    计算两个矩阵的乘法。
+    :param matrix1: 第一个矩阵 (二维列表)
+    :param matrix2: 第二个矩阵 (二维列表)
+    :return: 相乘后的矩阵 (二维列表)
+    """
+    if len(matrix1[0]) != len(matrix2):
+        raise ValueError("第一个矩阵的列数必须等于第二个矩阵的行数")
+    result = [[0 for _ in range(len(matrix2[0]))] for _ in range(len(matrix1))]
+    for i in range(len(matrix1)):
+        for j in range(len(matrix2[0])):
+            for k in range(len(matrix2)):
+                result[i][j] += matrix1[i][k] * matrix2[k][j]
+    return result
+
+def matrix_transpose(matrix):
+    """
+    计算矩阵的转置。
+    :param matrix: 输入矩阵 (二维列表)
+    :return: 转置后的矩阵 (二维列表)
+    """
+    return [list(row) for row in zip(*matrix)]
+
+def matrix_scalar_mul(matrix, scalar):
+    """
+    计算矩阵与标量的乘法。
+    :param matrix: 输入矩阵 (二维列表)
+    :param scalar: 标量值 (整数或浮点数)
+    :return: 乘法结果矩阵 (二维列表)
+    """
+    return [[scalar * element for element in row] for row in matrix]
+
+def list_max(nums, n):
+    """
+    找到数组中第 N 大的数。
+    :param nums: 输入的数组 (list)
+    :param n: 第 N 大的数 (int)
+    :return: 第 N 大的数
+    """
+    if not (1 <= n <= len(nums)):
+        raise ValueError("N 必须在 1 到数组长度之间")
+    return sorted(nums, reverse=True)[n - 1]
+
+def max(*nums, n):
+    """
+    找到多个数中第 N 大的数。
+    :param nums: 输入的多个数
+    :param n: 第 N 大的数 (int)
+    :return: 第 N 大的数
+    """
+    # 修改：将 *nums 转换为列表以统一处理
+    nums = list(nums)
+    if not (1 <= n <= len(nums)):
+        raise ValueError("N 必须在 1 到输入数的个数之间")
+    return sorted(nums, reverse=True)[n - 1]
+
+def list_max_index(nums, n):
+    """
+    找到数组中第 N 大的数的索引。
+    :param nums: 输入的数组 (list)
+    :param n: 第 N 大的数 (int)
+    :return: 第 N 大的数的索引
+    """
+    if not (1 <= n <= len(nums)):
+        raise ValueError("N 必须在 1 到数组长度之间")
+    sorted_indices = sorted(range(len(nums)), key=lambda i: nums[i], reverse=True)
+    return sorted_indices[n - 1]
+
+def max_index(*nums, n):
+    """
+    找到多个数中第 N 大的数的索引。
+    :param nums: 输入的多个数
+    :param n: 第 N 大的数 (int)
+    :return: 第 N 大的数的索引
+    """
+    if not (1 <= n <= len(nums)):
+        raise ValueError("N 必须在 1 到输入数的个数之间")
+    sorted_indices = sorted(range(len(nums)), key=lambda i: nums[i], reverse=True)
+    return sorted_indices[n - 1]
+
+def list_min(nums, n):
+    """
+    找到数组中第 N 小的数。
+    :param nums: 输入的数组 (list)
+    :param n: 第 N 小的数 (int)
+    :return: 第 N 小的数
+    """
+    if not (1 <= n <= len(nums)):
+        raise ValueError("N 必须在 1 到数组长度之间")
+    return sorted(nums)[n - 1]
+
+def min(*nums, n):
+    """
+    找到多个数中第 N 小的数。
+    :param nums: 输入的多个数
+    :param n: 第 N 小的数 (int)
+    :return: 第 N 小的数
+    """
+    # 修改：将 *nums 转换为列表以统一处理
+    nums = list(nums)
+    if not (1 <= n <= len(nums)):
+        raise ValueError("N 必须在 1 到输入数的个数之间")
+    return sorted(nums)[n - 1]
+
+def list_min_index(nums, n):
+    """
+    找到数组中第 N 小的数的索引。
+    :param nums: 输入的数组 (list)
+    :param n: 第 N 小的数 (int)
+    :return: 第 N 小的数的索引
+    """
+    if not (1 <= n <= len(nums)):
+        raise ValueError("N 必须在 1 到数组长度之间")
+    sorted_indices = sorted(range(len(nums)), key=lambda i: nums[i])
+    return sorted_indices[n - 1]
+
+def min_index(*nums, n):
+    """
+    找到多个数中第 N 小的数的索引。
+    :param nums: 输入的多个数
+    :param n: 第 N 小的数 (int)
+    :return: 第 N 小的数的索引
+    """
+    if not (1 <= n <= len(nums)):
+        raise ValueError("N 必须在 1 到输入数的个数之间")
+    sorted_indices = sorted(range(len(nums)), key=lambda i: nums[i])
+    return sorted_indices[n - 1]
+
+def math_help():
+    """提供模块帮助信息"""
+    print("以下是可用的函数:")
+    print("- gcd(*nums: int) -> int: 计算多个整数的最大公约数")
+    print("- lcm(*nums: int) -> int: 计算多个整数的最小公倍数")
+    print("- is_prime(n) -> bool: 判断一个整数是否为素数")
+    print("- comb(n: int, k: int) -> int: 计算组合数 C(n, k)")
+    print("- pow(x, y): 快速计算 x 的 y 次幂")
+    print("- sha256(input_string: str) -> str: 使用 SHA-256 算法加密字符串")
+    print("- sha3_256(input_string: str) -> str: 使用 SHA3-256 算法加密字符串")
+    print("- sha3_512(input_string: str) -> str: 使用 SHA3-512 算法加密字符串")
+    print("- fib_list(n) -> list: 生成包含前 N 项的斐波那契数列")
+    print("- fib(n) -> int: 返回第 N 项的斐波那契数")
+    print("- pell_list(n) -> list: 生成包含前 N 项的佩尔数列")
+    print("- pell(n) -> int: 返回第 N 项的佩尔数")
+    print("- factor(n: int) -> list: 分解整数 n 的质因数")
+    print("- manhattan_d(point1, point2): 计算两个点之间的曼哈顿距离")
+    print("- euclidean_d(point1, point2, precision=None): 计算两个点之间的欧几里得距离，可指定小数位数")
+    print("- matrix_add(matrix1, matrix2): 计算两个矩阵的加法")
+    print("- matrix_sub(matrix1, matrix2): 计算两个矩阵的减法")
+    print("- matrix_mu(matrix1, matrix2): 计算两个矩阵的乘法")
+    print("- matrix_transpose(matrix): 计算矩阵的转置")
+    print("- matrix_scalar_mul(matrix, scalar): 计算矩阵与标量的乘法")
+    print("- list_max(nums, n): 找到数组中第 N 大的数")
+    print("- max(*nums, n): 找到多个数中第 N 大的数, 输入n时请注意使用n = [num]")
+    print("- list_max_index(nums, n): 找到数组中第 N 大的数的索引")
+    print("- max_index(*nums, n): 找到多个数中第 N 大的数的索引, 输入n时请注意使用n = [num]")
+    print("- list_min(nums, n): 找到数组中第 N 小的数")
+    print("- min(*nums, n): 找到多个数中第 N 小的数, 输入n时请注意使用n = [num]")
+    print("- list_min_index(nums, n): 找到数组中第 N 小的数的索引")
+    print("- min_index(*nums, n): 找到多个数中第 N 小的数的索引, 输入n时请注意使用n = [num]")

mlymath-0.1.0/mlymath.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.2
+Name: mlymath
+Version: 0.1.0
+Author: mly
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Dynamic: author
+Dynamic: classifier
+Dynamic: requires-python

mlymath-0.1.0/mlymath.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+setup.py
+math/__init__.py
+math/math.py
+mlymath.egg-info/PKG-INFO
+mlymath.egg-info/SOURCES.txt
+mlymath.egg-info/dependency_links.txt
+mlymath.egg-info/top_level.txt
+morse/__init__.py
+morse/morse.py
+sort/__init__.py
+sort/sort.py

mlymath-0.1.0/mlymath.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mlymath-0.1.0/mlymath.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+math
+morse
+sort

mlymath-0.1.0/morse/__init__.py

@@ -0,0 +1,11 @@
+from .morse import (
+    morse,
+    unmorse,
+    morse_help
+)
+
+__all__ = [
+    "morse",
+    "unmorse",
+    "morse_help"
+]

mlymath-0.1.0/morse/morse.py

@@ -0,0 +1,56 @@
+# 扩展摩尔斯电码映射表
+MORSE_CODE_DICT = {
+    'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 
+    'G': '--.', 'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 
+    'M': '--', 'N': '-.', 'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.', 
+    'S': '...', 'T': '-', 'U': '..-', 'V': '...-', 'W': '.--', 'X': '-..-', 
+    'Y': '-.--', 'Z': '--..', '1': '.----', '2': '..---', '3': '...--', 
+    '4': '....-', '5': '.....', '6': '-....', '7': '--...', '8': '---..', 
+    '9': '----.', '0': '-----', ',': '--..--', '.': '.-.-.-', '?': '..--..', 
+    "'": '.----.', '!': '-.-.--', '/': '-..-.', '(': '-.--.', ')': '-.--.-', 
+    '&': '.-...', ':': '---...', ';': '-.-.-.', '=': '-...-', '+': '.-.-.', 
+    '-': '-....-', '_': '..--.-', '"': '.-..-.', '$': '...-..-', '@': '.--.-.',
+    'Ä': '.-.-', 'Á': '.--.-', 'Å': '.--.-', 'Ch': '----', 'É': '..-..', 
+    'Ñ': '--.--', 'Ö': '---.', 'Ü': '..--'
+}
+
+# 反向映射表
+REVERSE_MORSE_CODE_DICT = {value: key for key, value in MORSE_CODE_DICT.items()}
+
+def morse(input_string: str) -> str:
+    """
+    将字符串转换为摩尔斯电码。
+    :param input_string: 输入的字符串
+    :return: 转换后的摩尔斯电码（单词间用'/'分隔）
+    """
+    words = input_string.upper().split()
+    morse_words = []
+    for word in words:
+        morse_word = ' '.join(MORSE_CODE_DICT[char] for char in word if char in MORSE_CODE_DICT)
+        morse_words.append(morse_word)
+    return '/'.join(morse_words)
+
+def unmorse(morse_code: str) -> str:
+    """
+    将摩尔斯电码转换为字符串。
+    :param morse_code: 输入的摩尔斯电码（单词间用'/'分隔）
+    :return: 转换后的字符串
+    """
+    morse_words = morse_code.split('/')
+    plain_words = []
+    for morse_word in morse_words:
+        plain_word = ''.join(REVERSE_MORSE_CODE_DICT[code] for code in morse_word.split() if code in REVERSE_MORSE_CODE_DICT)
+        plain_words.append(plain_word)
+    return ' '.join(plain_words)
+
+# 新增：摩尔斯电码帮助函数
+def morse_help():
+    """
+    打印摩尔斯电码的使用帮助信息。
+    """
+    print("以下是支持的字符及其对应的摩尔斯电码：")
+    for char, code in MORSE_CODE_DICT.items():
+        print(f"{char}: {code}")
+    print("以下是可以使用的函数：")
+    print("- morse(input_string): 将字符串转换为摩尔斯电码")
+    print("- unmorse(morse_code): 将摩尔斯电码转换为字符串")

mlymath-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mlymath-0.1.0/setup.py

@@ -0,0 +1,14 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='mlymath',
+    version='0.1.0',
+    packages=find_packages(),
+    author='mly',
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.6',
+)

mlymath-0.1.0/sort/__init__.py

@@ -0,0 +1,27 @@
+from .sort import (
+    quick_sort,
+    shell_sort,
+    heap_sort,
+    bucket_sort,
+    insertion_sort,
+    bubble_sort,
+    merge_sort,
+    selection_sort,
+    counting_sort,
+    radix_sort,
+    sort_help
+)
+
+__all__ = [
+    'quick_sort',
+    'shell_sort',
+    'heap_sort',
+    'bucket_sort',
+    'insertion_sort',
+    'bubble_sort',
+    'merge_sort',
+    'selection_sort',
+    'counting_sort',
+    'radix_sort',
+    'sort_help'
+]

mlymath-0.1.0/sort/sort.py

@@ -0,0 +1,178 @@
+def quick_sort(arr, reverse=False):
+    if len(arr) <= 1:
+        return arr
+
+    pivot = arr[len(arr) // 2]
+    left = [x for x in arr if x < pivot]
+    middle = [x for x in arr if x == pivot]
+    right = [x for x in arr if x > pivot]
+
+    # 递归调用时不传递 reverse 参数，仅在最终结果中应用 reverse
+    result = quick_sort(left) + middle + quick_sort(right)
+    return result[::-1] if reverse else result
+
+def shell_sort(arr, reverse=False):
+    n = len(arr)
+    gap = n // 2  # 初始增量
+    
+    while gap > 0:
+        for i in range(gap, n):
+            temp = arr[i]
+            j = i
+            # 对当前增量的子序列进行插入排序
+            while j >= gap and arr[j - gap] > temp:
+                arr[j] = arr[j - gap]
+                j -= gap
+            arr[j] = temp
+        gap //= 2  # 减小增量
+    return arr[::-1] if reverse else arr
+
+def heap_sort(arr, reverse=False):
+    import heapq
+    arr = list(arr)  # 复制输入列表，避免修改原始数据
+    if not arr:
+        return arr
+    heapq.heapify(arr)
+    result = [heapq.heappop(arr) for _ in range(len(arr))]
+    return result[::-1] if reverse else result
+
+def bucket_sort(arr, reverse=False):
+    if not arr:
+        return arr
+
+    max_val = max(arr)
+    min_val = min(arr)
+    range_val = max_val - min_val
+
+    if range_val == 0:
+        return arr  # 如果所有元素相同，直接返回
+
+    # 动态调整桶数量
+    bucket_count = max(10, int(len(arr) ** 0.5))  # 桶数量为 sqrt(n) 或至少 10
+    buckets = [[] for _ in range(bucket_count)]
+
+    for num in arr:
+        index = int((num - min_val) * (bucket_count - 1) / range_val)
+        buckets[index].append(num)
+
+    sorted_arr = []
+    for bucket in buckets:
+        sorted_arr.extend(sorted(bucket))
+
+    return sorted_arr[::-1] if reverse else sorted_arr
+
+def insertion_sort(arr, reverse=False):
+    if not arr:
+        return arr
+    for i in range(1, len(arr)):
+        key = arr[i]
+        j = i - 1
+        while j >= 0 and key < arr[j]:
+            arr[j + 1] = arr[j]
+            j -= 1
+        arr[j + 1] = key
+    return arr[::-1] if reverse else arr
+
+def bubble_sort(arr, reverse=False):
+    if not arr:
+        return arr
+    n = len(arr)
+    for i in range(n):
+        for j in range(0, n-i-1):
+            if arr[j] > arr[j+1]:
+                arr[j], arr[j+1] = arr[j+1], arr[j]
+    return arr[::-1] if reverse else arr
+
+def merge_sort(arr, reverse=False):
+    if len(arr) <= 1:
+        return arr
+    mid = len(arr) // 2
+    left = merge_sort(arr[:mid])
+    right = merge_sort(arr[mid:])
+    
+    merged = []
+    left_idx, right_idx = 0, 0
+    while left_idx < len(left) and right_idx < len(right):
+        if left[left_idx] < right[right_idx]:
+            merged.append(left[left_idx])
+            left_idx += 1
+        else:
+            merged.append(right[right_idx])
+            right_idx += 1
+    merged.extend(left[left_idx:])
+    merged.extend(right[right_idx:])
+    return merged[::-1] if reverse else merged
+
+def selection_sort(arr, reverse=False):
+    if not arr:
+        return arr
+    for i in range(len(arr)):
+        min_idx = i
+        for j in range(i+1, len(arr)):
+            if arr[j] < arr[min_idx]:
+                min_idx = j
+        arr[i], arr[min_idx] = arr[min_idx], arr[i]
+    return arr[::-1] if reverse else arr
+
+def counting_sort(arr, reverse=False):
+    if not arr:
+        return arr
+    max_val = max(arr)
+    min_val = min(arr)
+    offset = -min_val  # 添加偏移量以支持负数
+    count = [0] * (max_val - min_val + 1)
+    for num in arr:
+        count[num + offset] += 1
+    sorted_arr = []
+    for i in range(len(count)):
+        sorted_arr.extend([i - offset] * count[i])  # 还原原始值
+    return sorted_arr[::-1] if reverse else sorted_arr
+
+def radix_sort(arr, reverse=False):
+    if not arr:
+        return arr
+    
+    # 分离负数和非负数
+    negatives = [-x for x in arr if x < 0]
+    non_negatives = [x for x in arr if x >= 0]
+    
+    def radix_sort_non_negative(nums):
+        max_val = max(nums) if nums else 0
+        exp = 1
+        while max_val // exp > 0:
+            count = [0] * 10
+            output = [0] * len(nums)
+            for num in nums:
+                index = (num // exp) % 10
+                count[index] += 1
+            for i in range(1, 10):
+                count[i] += count[i-1]
+            i = len(nums) - 1
+            while i >= 0:
+                index = (nums[i] // exp) % 10
+                output[count[index]-1] = nums[i]
+                count[index] -= 1
+                i -= 1
+            nums = output.copy()
+            exp *= 10
+        return nums
+    
+    # 对负数和非负数分别排序
+    negatives_sorted = [-x for x in radix_sort_non_negative(negatives)[::-1]]
+    non_negatives_sorted = radix_sort_non_negative(non_negatives)
+    
+    result = negatives_sorted + non_negatives_sorted
+    return result[::-1] if reverse else result
+
+def sort_help():
+    print("可用的排序算法：")
+    print("- quick_sort: 使用快速排序算法对数组进行排序。可通过 reverse 参数控制排序顺序（默认正序）")
+    print("- shell_sort: 使用希尔排序算法对数组进行排序。可通过 reverse 参数控制排序顺序（默认正序）")
+    print("- heap_sort: 使用堆排序算法对数组进行排序。可通过 reverse 参数控制排序顺序（默认正序）")
+    print("- bucket_sort: 使用桶排序算法对数组进行排序。可通过 reverse 参数控制排序顺序（默认正序）")
+    print("- insertion_sort: 使用插入排序算法对数组进行排序。可通过 reverse 参数控制排序顺序（默认正序）")
+    print("- bubble_sort: 使用冒泡排序算法对数组进行排序。可通过 reverse 参数控制排序顺序（默认正序）")
+    print("- merge_sort: 使用归并排序算法对数组进行排序。可通过 reverse 参数控制排序顺序（默认正序）")
+    print("- selection_sort: 使用选择排序算法对数组进行排序。可通过 reverse 参数控制排序顺序（默认正序）")
+    print("- counting_sort: 使用计数排序算法对数组进行排序。可通过 reverse 参数控制排序顺序（默认正序）")
+    print("- radix_sort: 使用基数排序算法对数组进行排序。可通过 reverse 参数控制排序顺序（默认正序）")