Arrays 如何使这种阵列组合算法更有效？

到目前为止，我有一个for循环，它经过a，然后是另一个for循环，它检查b的值，然后取c的最高值并将其放入新数组中

D = [0, 0, 0]
for i in A
    highestToAdd = 0
    for j in B
        if B[j] < A[i]
            if C[j] > highestToAdd 
                highestToAdd = C[j]
    D[i] = highestToAdd
return D

在这里你可以看到，我们得到了25个两次，我们不得不多次循环整个b，以找到c中的最高值

正如你所看到的，我会一次又一次地循环a的每个值和b的每个值（特别是当3个数组大小增加时），我应该采取什么方向

编辑-较大样本

A = [5, 2, 1, 9, 3, 1, 5, 4, 2, 2]
B = [8, 1, 7, 10, 6, 2, 5, 2, 4, 3]
C = [9, 5, 8, 4, 6, 10, 3, 9, 6, 8]

would result in
D = [10, 10, 5, 10, 10, 5, 10, 10, 10, 10]

---

您可以将B的每个元素与其在C中的匹配元素相关联，然后按值对组合的A&B进行排序

即

然后在处理过程中，取C中匹配元素的最大值，并在到达它们时将它们与A的元素关联

(0,B,3): max = 3
(1,A): A.1 is associated with 3
(2,B,25): max = 25
(3,A): A.3 is associated with 25
(5,B,5): max = 25
(7,A): A.7 is associated with 25.

最后答覆：[25,3,25]

---

运行时间：O（n log n）

我不确定这个逻辑，但它至少适用于示例测试

我将@Dave建议的

B

和

C

元素成对存储，并按

C

值的降序对列表进行排序

现在，我做了如下操作：对于每个元素

（ci，bi）

，在

A

中查找所有元素，以便

aj>bi

。将

j

th位置标记为已访问（以防止以后重新分配其他

ci

），并将

ci

存储在输出数组中的

j

th索引处

A = [3, 1, 7]
B = [5, 0, 2]
C = [5, 3, 25]
E = []
for i in range(len(C)):
    E.append((C[i], B[i]))

E.sort(reverse = True)

D = {}
visited = [False] * len(B)
for c, b in E:
    ind = 0
    for a in A:
        if not visited[ind] and a >= b:
            D[ind] = c
            visited[ind] = True
        ind += 1

print(D)

---

我很困惑，你把B的每个元素和C中匹配的元素联系起来是什么意思？@Casabias意思是把它们成对地放在一起（0,3）、（2,25）、（5,5），其中第一个元素来自B，第二个是对应的元素来自C。在这个答案中，他在一对中放了一个B，以装饰它，并将它们与a的元素区分开来，他用一个A.@Casabias装饰，按第一个组件对它们进行排序。通过这种方式，B的元素被排序，A的元素也被排序，并且在两者之间，B的元素小于前面的元素。@Casabias在从左到右移动列表时保持最大值。当您到达A的一个元素时，您将输出当前最大值。所以，你读（0,3）。当前最大值为3。然后读取（1），这是A的一个元素。输出当前最大值，3。然后你读（2,25）。当前最大值变为25。读取（3）时，由于它是A中的一个元素，因此输出当前最大值25。当您读取下一个条目（5,5）时，当前最大值不会改变。然后你读（7）。因为它是A中的一个元素，所以输出的是当前最大值，仍然是25。@Casabias顺便说一句，您可能会注意到这些值是作为3、25、25输出的，而不是作为25、3、25输出的。但请注意，在输出它们时，您知道A的哪个元素与每个输出关联。您需要将A的元素保留在一个结构中，以便为A的每个元素查找其在原始数组中的位置。这可以通过将a的元素映射到其在原始a中的位置的哈希表来实现。不确定访问的位置，因为值a=[5,2,1,9,3,1,5,4,2,2]，B=[8,1,7,10,6,2,5,2,4,3]和C=[9,5,8,4,6,10,3,9,6,8]是不正确的，D应该是=[10,10,10,10,10]@Casabias，有一个小错误，它不是

a>b

，而是

a>=b

。然后它对给定的较大输入有效。进行了编辑，请查看！谢谢如果数组大小最大为10个元素，并且每个元素都在1到10之间，那么对数组进行排序不会比上面的2个循环花费更多的时间吗？在这种情况下，使用插入排序可能会有所帮助。我在某个地方读到过，对于数量较少的元素，插入排序工作得更快。你可以设计一个方法

custom_sort（）

，它检查元素的数量是否少于，比如说10个，然后进行插入排序，否则使用

sort（）

方法。这很好，但是在比较之后，当与2个循环的蛮力进行比较时，排序需要花费太多纳秒，蛮力也相当慢，如果我想求D的和，整个过程需要改变吗？到目前为止，我只是把c加到总数中，而不是把它存到D中。

(0,B,3): max = 3
(1,A): A.1 is associated with 3
(2,B,25): max = 25
(3,A): A.3 is associated with 25
(5,B,5): max = 25
(7,A): A.7 is associated with 25.

A = [3, 1, 7]
B = [5, 0, 2]
C = [5, 3, 25]
E = []
for i in range(len(C)):
    E.append((C[i], B[i]))

E.sort(reverse = True)

D = {}
visited = [False] * len(B)
for c, b in E:
    ind = 0
    for a in A:
        if not visited[ind] and a >= b:
            D[ind] = c
            visited[ind] = True
        ind += 1

print(D)