高效程序打印n个数的因数

如果需要打印一个数的因数，我们可以对该数进行一次循环，判断每个数是否是它的因数，复杂度为 O(n)。但是如果需要打印 n 个数的因数呢？循环嵌套 n 次，复杂度为 O(n^2)，效率非常低。

在这里，我们介绍一种高效的方法，可以同时打印 n 个数的因数，复杂度仅为 O(nlogn)。

方法介绍

我们可以把 n 个数的因数拆分成 n 个集合，每个集合分别存储每个数的因数。以 10, 20, 30, 40, 50 这五个数为例，它们的因数分别为：

• 10 的因数为 1, 2, 5, 10
• 20 的因数为 1, 2, 4, 5, 10, 20
• 30 的因数为 1, 2, 3, 5, 6, 10, 15, 30
• 40 的因数为 1, 2, 4, 5, 8, 10, 20, 40
• 50 的因数为 1, 2, 5, 10, 25, 50

我们可以用一个数组存储每个数的因数，并按照从小到大的顺序排序，例如：

factors = [
  [1, 2, 5, 10],
  [1, 2, 4, 5, 10, 20],
  [1, 2, 3, 5, 6, 10, 15, 30],
  [1, 2, 4, 5, 8, 10, 20, 40],
  [1, 2, 5, 10, 25, 50]
]

我们维护一个长度为 n 的指针数组 pointers，初始值都为 0。指针数组用来表示每个集合当前遍历到了哪个位置，例如 pointers[2]=3 表示第三个集合当前遍历到了 15 这个位置。

我们进行如下操作：

1. 首先找到所有集合中最小的数，记录它的值 min_val。
2. 遍历指针数组 pointers，找到所有指向集合中值为 min_val 的位置，打印 min_val。
3. 把指针数组中所有指向集合中值为 min_val 的位置加一。

重复以上操作，直到所有集合的指针都遍历到了末尾为止。

代码实现

def print_factors(nums):
    # 计算每个数的因数，并按照从小到大排序
    factors = [[1] for _ in range(len(nums))]
    for i in range(len(nums)):
        for j in range(2, int(nums[i] ** 0.5) + 1):
            if nums[i] % j == 0:
                factors[i].append(j)
                if j != nums[i] // j:
                    factors[i].append(nums[i] // j)
        factors[i].append(nums[i])
        factors[i].sort()

    # 初始化指针数组
    pointers = [0] * len(nums)

    # 不断寻找集合中最小的数，并打印
    while True:
        min_val = float('inf')
        flag = True
        for i in range(len(nums)):
            if pointers[i] < len(factors[i]) and factors[i][pointers[i]] < min_val:
                min_val = factors[i][pointers[i]]
                flag = False
        if flag:
            break
        for i in range(len(pointers)):
            if pointers[i] < len(factors[i]) and factors[i][pointers[i]] == min_val:
                print(min_val, end=' ')
                pointers[i] += 1
    print()

测试

对于样例输入 [10, 20, 30, 40, 50]，程序应该输出：

1 2 5 10 20 3 6 15 30 4 8 40 5 10 25 50

总结

这种方法的时间复杂度为 O(nlogn)，空间复杂度为 O(nlogn)，与暴力枚举的时间复杂度相比，效率有了很大的提升。

但是，需要注意的是，该方法所用的空间很大，如果 n 特别大，可能会导致内存溢出，需要控制 n 的大小，或者使用其他数据结构来代替数组存储因数。