提高从嵌套列表中删除 Intersection 并返回列表的性能

Question

我有一个带有两个参数的函数（2 个不同的嵌套列表，列表大小可以不同）。

问题是我面临数百万数组的性能问题。

def function(a,b):

第一个参数是一个嵌套列表，例如(a = [[1,2,3,4,5],[3,4,5,6]]))

第二个参数也是一个嵌套列表，例如(b = [[1,2,3,4,5],[3,4,5,6]]))。

我正在编写一个函数，该函数返回另一个列表，该列表从第一个数组中删除与第二个参数的交互。

例如是

a  =[[3--15],[2--20],[5--10]]
b = [[3---5],[8--10]]  // [[3,4,5],[8,9,10]]
o/p is :[[2],[6,7],[11,12---20]]

举个简单的例子：

a = [[1,2,3,4,5],[2,3,4,--20]]
b = [[3,4,5,6,7]]
op = [[1,2],[8,9,---20]]

我目前设法使用以下逻辑：

• 将所有的 'a' 集合到一个列表中，比如说 mg [] //mg= merge
• 将所有的 'b' 集合到另一个列表中，比如说 ng [] //ng =negative
• 初始化一个空列表 op = [] //输出
• 初始化另一个空列表 z =[]，这个我将追加到 op
• 创建一个以元素开头的 for 循环 在“mg”中，并检查是否存在于“ng”中，如果在中遇到该元素 ng，然后创建一个新的 z = [] ，否则附加到 z

这是我的代码：

def function (a,b):
    mg = [] ## merge all data in "a"
    ng = [] ## merge all data in "b"
    for out in a: ##function to merge data in a
        for i in out:
            if i in mg:
                continue
            else:
                mg.append(i)
    for out in b: ##function to merge data in b
        for i in out:
            if i in ng:
                continue
            else:
                ng.append(i)
    ng = sorted(ng) ## sort out the value in a
    mg = sorted(mg) ## sort out the value in b
    op = []
    z =[]
    for m in mg: ## some simple logic that breaks array and creates a new one for output
        if m in ng: 
            if len(z) !=0:
                op.append(z)
                z =[]
            else:
                continue
        else:
            z.append(m)
    op.append(z)
    print("##"*20)
    print(op)
    return op

如果数组大小在 100 或 1000 范围内很小，则代码可以完美运行，但如果数组范围以百万为单位（例如 [[1,2,3][5,6,7-------10,000,00]]，则代码将花费大量时间或在某些系统中变得无响应内存较少。我发现我使用的合并功能存在问题，它试图追加，但也可能存在其他问题。

我尝试在谷歌上搜索任何可能有帮助的算法，并尝试创建一个新算法，但我的大脑开始出现故障，我一无所知。

我正在寻找任何可以帮助我解决这个问题的解决方案或建议。

Answer 1

通常有两种方法可以更有效地做到这一点。

两种方式都从创建两个组合列表开始，就像您当前所做的那样。

第一种方法是对两个列表进行排序和去重。现在您有两个排序列表，您可以进行双向合并，只选择两个列表中都存在的项目。

另一种方法是从两个列表中的一个创建字典（映射）。然后逐项浏览另一个列表，并检查该项目是否存在于字典中。如果是，则将其放入输出数组中。

第一种方式的复杂度为 O(n log n + m log m)，其中 n 和 m 是两个列表的长度。

第二种方法是 O(m+n)：O(m) 从一个列表构建字典，O(n) 将另一个列表中的所有项目与字典检查。