Delphi 列表交叉点

我想计算一个列表“交集”。问题是：

L1 = [1, 0, 2, 3, 1 , 3, 0, 5]
L2 = [3, 5]

那么结果就是

L3 = [0, 0, 0, 1, 0, 1, 0, 1]

然后我将把这个结果转换成一个字节。在这种情况下，十进制格式为21

---

我想在德尔福，我需要这样做的效率。有没有比O（m*n）更好的方法来解决这个问题呢？

不管您需要访问每个列表中的每个元素来比较值。嵌套循环将在O（n^2）中完成此操作，并且转换应该只是本地工作

---

编辑：我注意到您想要一个比O（n*m）更好的运行时。

不管您需要访问每个列表中的每个元素来比较值。嵌套循环将在O（n^2）中完成此操作，并且转换应该只是本地工作

---

编辑：我注意到您需要一个比O（n*m）更好的运行时。

这里有一个函数，它可以实现您想要的功能。我将

L2

定义为一个集合，而不是一个数组，因为您说过所有值都将放入

字节中。其复杂性为O（n）；检查集合成员资格以固定时间运行。但是由于结果需要适合一个字节，因此
L1
的长度必须限制为8，因此该函数的复杂性实际上是O（1）

函数ArrayMembersInSet（常量L1:字节数组；常量L2:字节集）：字节；
变量
i：整数；
b：字节；
开始
Assert（Length（L1）这里有一个函数，它应该做你想要做的事情。我将
L2
定义为一个集合而不是数组，因为你说过你所有的值都可以放在
字节中。它的复杂度是O（n）；检查集合成员资格以恒定时间运行。但由于结果需要适合一个字节，因此
L1
的长度必须限制为8，因此此函数的复杂性实际上是O（1）

函数ArrayMembersInSet（常量L1:字节数组；常量L2:字节集）：字节；
变量
i：整数；
b：字节；
开始
Assert（Length（L1）Rob的答案适用于这种特殊情况。对于需要比较两个列表的更一般的情况，如果两个列表都已排序，则可以在O（m+n）时间内进行比较。（或者，如果必须先对它们进行排序，则在O（n logn）时间内进行比较，但这仍然比O（m*n）快得多。）

基本列表比较算法如下所示：

procedure ListCompare(list1, list2: TWhateverList; [Add extra params here]);
var
  i, j: integer;
begin
  i := 0;
  j := 0;
  while (i < list1.Count) and (j < list2.Count) do
  begin
    if list1[i] < list2[j] then
    begin
      //handle this appropriately
      inc(i);
    end
    else if list1[i] > list2[j] then
    begin
      //handle this appropriately
      inc(j);
    end
    else //both elements are equal
    begin
      //handle this appropriately
      inc(i);
      inc(j);
    end;
  end;

  //optional cleanup, if needed:
  while (i < list1.Count) do
  begin
    //handle this appropriately
    inc(i);
  end;
  while (j < list2.Count) do
  begin
    //handle this appropriately
    inc(j);
  end;
end;

procedure-ListCompare（list1，list2:TWhateverList；[在此处添加额外参数]）；
变量
i、 j：整数；
开始
i:=0；
j:=0；
而（ilist2[j]，则
开始
//妥善处理
公司（j）；
终止
else//两个元素相等
开始
//妥善处理
公司（一）；
公司（j）；
终止
终止
//可选清理，如果需要：
而（我

这可以通过更改“适当地处理”来为一系列任务定制，包括列表交叉点放置，并保证运行的步数不会超过两个列表中加在一起的步数。对于列表交集，让equals大小写将值添加到一些输出中，而其他两个则不执行任何操作，只推进计数器，您可以取消可选的清理

使用此算法的一种方法是将顶部的额外参数设置为函数指针，并传入将处理适当情况的例程，或者nil不执行任何操作（如果使用该方法，请确保在调用它们之前检查nil！）这样，您只需编写一次基本代码。
Rob的答案适用于这种特定情况。对于需要比较两个列表的更一般情况，如果两个列表都已排序，您可以在O（m+n）时间内完成此操作。（或者，如果必须先对其排序，则可以在O（n log n）时间内完成，但这仍然比O（m*n）快得多。）

基本列表比较算法如下所示：

procedure ListCompare(list1, list2: TWhateverList; [Add extra params here]);
var
  i, j: integer;
begin
  i := 0;
  j := 0;
  while (i < list1.Count) and (j < list2.Count) do
  begin
    if list1[i] < list2[j] then
    begin
      //handle this appropriately
      inc(i);
    end
    else if list1[i] > list2[j] then
    begin
      //handle this appropriately
      inc(j);
    end
    else //both elements are equal
    begin
      //handle this appropriately
      inc(i);
      inc(j);
    end;
  end;

  //optional cleanup, if needed:
  while (i < list1.Count) do
  begin
    //handle this appropriately
    inc(i);
  end;
  while (j < list2.Count) do
  begin
    //handle this appropriately
    inc(j);
  end;
end;

procedure-ListCompare（list1，list2:TWhateverList；[在此处添加额外参数]）；
变量
i、 j：整数；
开始
i:=0；
j:=0；
而（ilist2[j]，则
开始
//妥善处理
公司（j）；
终止
else//两个元素相等
开始
//妥善处理
公司（一）；
公司（j）；
终止
终止
//可选清理，如果需要：
而（我

这可以通过更改“适当地处理”来为一系列任务定制，包括列表交叉点放置，并保证运行的步数不会超过两个列表中加在一起的步数。对于列表交集，让equals大小写将值添加到一些输出中，而其他两个则不执行任何操作，只推进计数器，您可以取消可选的清理

使用此算法的一种方法是将顶部的额外参数设置为函数指针，并传入将处理适当情况的例程，或者nil不执行任何操作（如果使用该方法，请确保在调用它们之前检查nil！）这样，您只需编写一次基本代码。
如果结果总是适合一个字节，那么我们可以假设
m=8
，对吗？L2中存储的值是否有上限？（特别是，它们是否总是介于0和255之间？）我也不明白你所说的交集是什么意思。根据你的数据，我猜L3=[0,0,0,1,0,0]，你犯了错误吗？我的结构是一个字节数组。L1有N个元素，L2有M个元素。交集将是O（M*N）。如果我在L1中找到一个L2元素，那么输出元素将是1或0。我找到元素“3”或“5”