Question

我已宣布类似以下的类型。

type
  TLikes = record
    Name            : string[20];
    favColours  : array of string[20];

  faves     = array of TLikes;

填充记录后，我将它们保存到二进制文件中，结构如下所示。

[John],     [Green]     [White]     [Blue]
[Paul],     [Blue]      [Red]       [White]     [Green]
[David],    [Red]       [Blue]      [Green]
[Bob],      [White]     [Blue]
[Peter],    [Blue]      [Green]     [Red]

很容易找出大卫喜欢的颜色。当我想要知道谁喜欢蓝色时，会出现一个小问题。所以我所做的就是构建第二个文件，就像这样......

[Blue],     [John]      [Paul]      [David]     [Peter]         [Bob]
[Red],      [David]     [Paul]      [Peter]
[White],    [Bob]       [David]     [John]      [Paul]
[Green],    [John]      [David]     [Paul]      [Peter]

但有些事情告诉我，我不应该真的需要创建第二个文件/数据结构，它看起来效率低下。

这是一个更大的问题......

如果我需要找到谁喜欢David喜欢的任何组合怎么办？我的结果将是......

Blue and red and green  =   Paul, David, Peter
Blue and red            =   Paul, David, Peter
Blue and green          =   John, Paul, David, Peter
Red and Green           =   Paul, David, Peter

我的问题是。

有没有更好的方法来构建数据/记录，这样我就可以弄清楚鲍勃和保罗的共同点（蓝色和白色）或者红色和白色的共同点（大卫和保罗）？

我想我需要指出我曾试图简化上面的例子。实际上，Tlikes.Name的数据将是......

之类的字符串

‘decabbadc’
‘bacddbcad’
‘eebadeaac’

这些字符串的数量级为200k +。而Tlikes.FavColours数据是一个文件名（这些文件大约有2k）。文件名表示包含Tlikes.Name字符串的文件。

我希望能够在给定Tlikes.Name字符串或给定文件名的字符串列表的情况下检索文件名列表。

NB - 有些东西让我想起'套装'，但是从我理解的那些东西来看，我的成分数量有限，我是否在正确的轨道上？

感谢您抽出宝贵时间阅读帖子。

Answer 1

这是一个通用集TSet<T>，它可以用作获取数据之间关系的工具。

TSet<T>可以保存简单类型的数据，而不是像普通Set类型那样限制为字节大小。

支持：

包括（添加）
排除（减法）
相交（相互包含，乘法）
对称差异（互斥，xor）
测试包含（在运营商中）
测试平等（等于运算符）
测试（＆gt; =运算符）
测试（＆lt; =运算符）
排序
BinarySearch的

使用TSet<T>对您的应用进行基准测试。

unit GenericSet;

interface

Uses
  System.Generics.Defaults,
  System.Generics.Collections;

Type
  TSet<T> = record
    // Include (union)
    class operator Add(const aSet: TSet<T>; aValue: T) : TSet<T>; overload;
    class operator Add(const aSet: TSet<T>; const aTArr: TArray<T>) : TSet<T>; overload;
    class operator Add(const aSet1: TSet<T>; const aSet2: TSet<T>) : TSet<T>; overload;
    // Exclude
    class operator Subtract(const aSet: TSet<T>; aValue: T): TSet<T>; overload;
    class operator Subtract(const aSet: TSet<T>; const aTArr: TArray<T>) : TSet<T>; overload;
    class operator Subtract(const aSet1: TSet<T>; const aSet2: TSet<T>) : TSet<T>; overload;
    // left in right, i.e right.Contains(left)
    class operator In(aValue: T; const aSet: TSet<T>): Boolean; overload;
    class operator In(const aTArr: TArray<T>; const aSet: TSet<T>): Boolean; overload;
    class operator In(const aSet1: TSet<T>; const aSet2: TSet<T>): Boolean; overload;
    // Intersect, mutually common, A and B
    class operator Multiply(const aSet: TSet<T>; aValue: T): TSet<T>; overload;
    class operator Multiply(const aSet: TSet<T>; const aTArr: TArray<T>): TSet<T>; overload;
    class operator Multiply(const aSet1,aSet2 : TSet<T>): TSet<T>; overload;
    // Symmetric difference, A xor B = (A+B) - A.Intersect(B)
    class operator LogicalXor(const aSet: TSet<T>; aValue: T): TSet<T>; overload;
    class operator LogicalXor(const aSet: TSet<T>; aTArr: TArray<T>): TSet<T>; overload;
    class operator LogicalXor(const aSet1,aSet2 : TSet<T>): TSet<T>; overload;
    //
    class operator Equal(const aSet: TSet<T>; aValue: T): Boolean; overload;
    class operator Equal(const aSet: TSet<T>; aTArr: TArray<T>): Boolean; overload;
    class operator Equal(const aSetLeft,aSetRight: TSet<T>): Boolean; overload;
    // SubsetOf (Left <= Right)
    class operator LessThanOrEqual(const aSet: TSet<T>; aValue: T): Boolean; overload;
    class operator LessThanOrEqual(const aSet: TSet<T>; aTArr: TArray<T>): Boolean; overload;
    class operator LessThanOrEqual(const aSetLeft,aSetRight: TSet<T>): Boolean; overload;
    // SupersetOf (Left >= Right)
    class operator GreaterThanOrEqual(const aSet: TSet<T>; aValue: T): Boolean; overload;
    class operator GreaterThanOrEqual(const aSet: TSet<T>; aTArr: TArray<T>): Boolean; overload;
    class operator GreaterThanOrEqual(const aSetLeft,aSetRight: TSet<T>): Boolean; overload;
    // Set creator
    class function Create(const aTArr: array of T; checkDuplicates: Boolean = False): TSet<T>; static;
  private
    FSetArray : array of T;
    FSorted : String; // !! Will be predefined as '' (=False) by compiler.
    function GetEmpty: Boolean; inline;
    function GetItem(index: Integer): T; inline;
    function GetItemCount: Integer; inline;
    function GetSorted: Boolean; inline;
    procedure SetSorted( sorted: Boolean); inline;
  public
    // Add
    procedure Include(aValue: T); overload;
    procedure Include(const aTArr: TArray<T>); overload;
    procedure Include(const aTArr: array of T); overload;
    procedure Include(const aSet: TSet<T>); overload;
    // Subtract; A=[1,2,3]; B=[2,3,4]; B.Exclude(A) = B-A = [4]
    procedure Exclude(aValue: T); overload;
    procedure Exclude(const aTArr: TArray<T>); overload;
    procedure Exclude(const aTArr: array of T); overload;
    procedure Exclude(const aSet: TSet<T>); overload;
    // Multiply (A and B) A=[1,2,3]; B=[2,3,4]; B.Intersect(A) = B*A = [2,3]
    function Intersect(aValue: T): TSet<T>; overload;
    function Intersect(const aTArr: TArray<T>): TSet<T>; overload;
    function Intersect(const aTArr: array of T): TSet<T>; overload;
    function Intersect(const aSet: TSet<T>): TSet<T>; overload;

    // A xor B; A=[1,2,3]; B=[2,3,4]; (A+B)-A.Intersect(B) = [1,4]
    function SymmetricDiff(aValue: T): TSet<T>; overload;
    function SymmetricDiff(const aTArr: TArray<T>): TSet<T>; overload;
    function SymmetricDiff(const aTArr: array of T): TSet<T>; overload;
    function SymmetricDiff(const aSet: TSet<T>): TSet<T>; overload;
    // Identical set
    function Equal(aValue: T): Boolean; overload;
    function Equal(const aTArr: array of T; checkDuplicates: Boolean = False): Boolean; overload;
    function Equal(const aTArr: TArray<T>; checkDuplicates: Boolean = False): Boolean; overload;
    function Equal(const aSet: TSet<T>): Boolean; overload;
    //  Self <= aSet
    function SubsetOf(aValue: T): Boolean; overload;
    function SubsetOf(const aTArr: array of T; checkDuplicates: Boolean = False): Boolean; overload;
    function SubsetOf(const aTArr: TArray<T>; checkDuplicates: Boolean = False): Boolean; overload;
    function SubsetOf(const aSet: TSet<T>): Boolean; overload;
    // Self >= aSet
    function SupersetOf(aValue: T): Boolean; overload;
    function SupersetOf(const aTArr: array of T; checkDuplicates: Boolean = False): Boolean; overload;
    function SupersetOf(const aTArr: TArray<T>; checkDuplicates: Boolean = False): Boolean; overload;
    function SupersetOf(const aSet: TSet<T>): Boolean; overload;
    // Is included
    function Contains(aValue: T): Boolean; overload;
    function Contains(const aTArr: array of T): Boolean; overload;
    function Contains(const aTArr: TArray<T>): Boolean; overload;
    function Contains(const aSet: TSet<T>): Boolean; overload;

    procedure Sort; // QuickSort
    function Search( aValue: T): Boolean; // BinarySearch (Set must be sorted)
    procedure Clear;
    property IsSorted: Boolean read GetSorted;
    property IsEmpty: Boolean read GetEmpty;
    property Items[index: Integer]: T read GetItem; default;
    property ItemCount: Integer read GetItemCount;
  end;

implementation

class function TSet<T>.Create(const aTArr: array of T; checkDuplicates: Boolean = False): TSet<T>;
var
  i,j,elements : Integer;
  duplicate : Boolean;
  c : IEqualityComparer<T>;
begin
  if checkDuplicates then
  begin
    c := TEqualityComparer<T>.Default;
    // This will remove duplicates
    SetLength(Result.FSetArray,Length(aTArr));
    elements := 0;
    for i := 0 to High(aTArr) do
    begin
      duplicate := False;
      for j := 0 to Pred(elements) do
      begin
        duplicate := c.Equals(Result.FSetArray[j],aTArr[i]);
        if duplicate then
          Break;
      end;
      if not duplicate then
      begin
        Result.FSetArray[elements] := aTArr[i];
        Inc(elements);
      end;
    end;
    SetLength(Result.FSetArray,elements);
  end
  else
  begin
    SetLength(Result.FSetArray, Length(aTArr));
    for i := 0 to High(aTArr) do
      Result.FSetArray[i] := aTArr[i];
  end;
end;

class operator TSet<T>.Add(const aSet: TSet<T>; aValue: T): TSet<T>;
begin
  Result := aSet;
  Result.Include(aValue);
end;

class operator TSet<T>.Add(const aSet: TSet<T>; const aTArr: TArray<T>): TSet<T>;
begin
  Result := aSet;
  Result.Include(aTArr);
end;

class operator TSet<T>.Add(const aSet1, aSet2: TSet<T>): TSet<T>;
begin
  Result := aSet1;
  Result.Include(aSet2);
end;

procedure TSet<T>.Include(aValue: T);
begin
  if not Contains(aValue) then begin
    SetLength(FSetArray,Length(FSetArray)+1);
    FSetArray[High(FSetArray)] := aValue;
    SetSorted(False);
  end;
end;

procedure TSet<T>.Include(const aSet: TSet<T>);
begin
  if Self.IsEmpty then
    Self := aSet
  else
    Include(aSet.FSetArray);
end;

procedure TSet<T>.Include(const aTArr: TArray<T>);
var
  i : Integer;
begin
  for i := 0 to High(aTArr) do
    Self.Include(aTArr[i]);
end;

procedure TSet<T>.Include(const aTArr: array of T);
var
  i : Integer;
begin
  for i := 0 to High(aTArr) do
    Self.Include(aTArr[i]);
end;

procedure TSet<T>.Exclude(const aTArr: TArray<T>);
var
  i : Integer;
begin
  for i := 0 to High(aTArr) do
    Exclude(aTArr[i]);
end;

procedure TSet<T>.Exclude(const aTArr: array of T);
var
  i : Integer;
begin
  for i := 0 to High(aTArr) do
    Exclude(aTArr[i]);
end;

procedure TSet<T>.Exclude(const aSet: TSet<T>);
begin
  Exclude(aSet.FSetArray);
end;

procedure TSet<T>.Exclude(aValue: T);
var
  i : Integer;
  c : IEqualityComparer<T>;
begin
  c := TEqualityComparer<T>.Default;
  for i := 0 to High(FSetArray) do
  begin
    if c.Equals(FSetArray[i],aValue) then
    begin
      SetLength(FSetArray,Length(FSetArray)); // Ensure unique dyn array
      if (i < High(FSetArray)) then
      begin
        FSetArray[i] := FSetArray[High(FSetArray)]; // Move last element
        Self.SetSorted(False);
      end;
      SetLength(FSetArray,Length(FSetArray)-1);
      Break;
    end;
  end;
end;

class operator TSet<T>.Subtract(const aSet1, aSet2: TSet<T>): TSet<T>;
begin
  Result := aSet1;
  Result.Exclude(aSet2.FSetArray);
end;

class operator TSet<T>.Subtract(const aSet: TSet<T>;
  const aTArr: TArray<T>): TSet<T>;
begin
  Result := aSet;
  Result.Exclude(aTArr);
end;

class operator TSet<T>.Subtract(const aSet: TSet<T>; aValue: T): TSet<T>;
begin
  Result := aSet;
  Result.Exclude(aValue);
end;

class operator TSet<T>.In(aValue: T; const aSet: TSet<T>): Boolean;
begin
  Result := aSet.Contains(aValue);
end;

class operator TSet<T>.In(const aTArr: TArray<T>; const aSet: TSet<T>): Boolean;
begin
  Result := aSet.Contains(aTArr);
end;

class operator TSet<T>.In(const aSet1: TSet<T>; const aSet2: TSet<T>): Boolean;
begin
  Result := aSet2.Contains(aSet1.FSetArray);
end;

function TSet<T>.Contains(aValue: T): Boolean;
var
  i : Integer;
  c : IEqualityComparer<T>;
begin
  if IsSorted then
  begin
    Result := Search(aValue);
  end
  else
  begin
    Result := false;
    c := TEqualityComparer<T>.Default;
    for i := 0 to High(FSetArray) do
      if c.Equals(FSetArray[i],aValue) then
        Exit(True);
  end;
end;

function TSet<T>.Contains(const aTArr: array of T): Boolean;
var
  i: Integer;
begin
  Result := High(aTArr) >= 0;
  for i := 0 to High(aTArr) do
  begin
    if IsSorted then
      Result := Search(aTArr[i])
    else
      Result := Contains(aTArr[i]);
    if not Result then
      Exit(false);
  end;
end;

function TSet<T>.Contains(const aTArr: TArray<T>): Boolean;
var
  i : Integer;
begin
  Result := High(aTArr) >= 0;
  for i := 0 to High(aTArr) do
  begin
    if IsSorted then
      Result := Search(aTArr[i])
    else
      Result := Contains(aTArr[i]);
    if not Result then
      Exit(false);
  end;
end;

function TSet<T>.Contains(const aSet: TSet<T>): Boolean;
begin
  Result := Contains(aSet.FSetArray);
end;

function TSet<T>.GetEmpty: Boolean;
begin
  Result := (Self.ItemCount = 0);
end;

function TSet<T>.GetItem(index: Integer): T;
begin
  Result := Self.FSetArray[index];
end;

function TSet<T>.GetItemCount: Integer;
begin
  Result := Length(Self.FSetArray);
end;

procedure TSet<T>.Clear;
begin
  SetLength(FSetArray,0);
  Self.SetSorted(False);
end;

// Get the mutually common elements, aka the intersect.
class operator TSet<T>.Multiply(const aSet: TSet<T>; aValue: T): TSet<T>;
begin
  Result:= aSet.Intersect(aValue);
end;

class operator TSet<T>.Multiply(const aSet: TSet<T>; const aTArr: TArray<T>): TSet<T>;
begin
  Result:= aSet.Intersect(aTArr);
end;

class operator TSet<T>.Multiply(const aSet1,aSet2: TSet<T>): TSet<T>;
begin
  Result := aSet1.Intersect(aSet2);
end;

function TSet<T>.Intersect(aValue : T): TSet<T>;
var
  i : Integer;
begin
  if Self.Contains(aValue) then
    Result.Include(aValue)
  else
    Result.Clear;
  Result.SetSorted(Result.ItemCount = 1);
end;

function TSet<T>.Intersect(const aSet: TSet<T>): TSet<T>;
var
  i,items : Integer;
begin
  SetLength(Result.FSetArray,aSet.ItemCount);
  items := 0;
  for i := 0 to High(aSet.FSetArray) do
  begin
    if Self.Contains(aSet.FSetArray[i]) then
    begin
      Result.FSetArray[items] := aSet.FSetArray[i];
      Inc(items);
    end;
  end;
  SetLength(Result.FSetArray,items);
  Result.SetSorted(Self.IsSorted and aSet.IsSorted);
end;

function TSet<T>.Intersect(const aTArr: array of T): TSet<T>;
var
  i : Integer;
begin
  for i := 0 to High(aTArr) do
  begin
    if Self.Contains(aTArr[i]) then
      Result.Include(aTArr[i]);
  end;
  Result.SetSorted(False);
end;

function TSet<T>.Intersect(const aTArr: TArray<T>): TSet<T>;
var
  i : Integer;
begin
  for i := 0 to High(aTArr) do
  begin
    if Self.Contains(aTArr[i]) then
      Result.Include(aTArr[i]);
  end;
  Result.SetSorted(False);
end;

//
function TSet<T>.Equal(aValue: T): Boolean;
begin
  Result := (Self.ItemCount = 1) and Self.Contains(aValue);
end;

function TSet<T>.Equal(const aTArr: array of T; checkDuplicates: Boolean = False): Boolean;
begin
  if checkDuplicates then
    Result :=
      (Self.ItemCount <= Length(aTArr)) and
      Self.Equal(TSet<T>.Create(aTArr,True)) // Remove possible duplicates
  else
    Result :=
      (Self.ItemCount = Length(aTArr)) and
      Self.Contains(aTArr);
end;

function TSet<T>.Equal(const aTArr: TArray<T>; checkDuplicates: Boolean = False): Boolean;
begin
  if checkDuplicates then
    Result :=
      (Self.ItemCount <= Length(aTArr)) and
      Self.Equal(TSet<T>.Create(aTArr,True)) // Remove possible duplicates
  else
    Result :=
      (Self.ItemCount = Length(aTArr)) and
      Self.Contains(aTArr);
end;

function TSet<T>.Equal(const aSet: TSet<T>): Boolean;
begin
  Result :=
    (Self.ItemCount = aSet.ItemCount) and
    Contains(aSet);
end;

class operator TSet<T>.Equal(const aSet: TSet<T>; aValue: T): Boolean;
begin
  Result := aSet.Equal(aValue);
end;

class operator TSet<T>.Equal(const aSet: TSet<T>; aTArr: TArray<T>): Boolean;
begin
  Result := aSet.Equal(aTArr,True);
end;

class operator TSet<T>.Equal(const aSetLeft,aSetRight: TSet<T>): Boolean;
begin
  Result := aSetLeft.Equal(aSetRight);
end;

//  Self <= aSet
function TSet<T>.SubsetOf(aValue: T): Boolean;
begin
 Result := (Self.ItemCount = 1) and Self.Equal(aValue);
end;

function TSet<T>.SubsetOf(const aTArr: array of T; checkDuplicates: Boolean = False): Boolean;
begin
  Result := Self.SubsetOf(TSet<T>.Create(aTArr,checkDuplicates));
end;

function TSet<T>.SubsetOf(const aTArr: TArray<T>; checkDuplicates: Boolean = False): Boolean;
begin
  Result := SubsetOf(TSet<T>.Create(aTArr,checkDuplicates));
end;

function TSet<T>.SubsetOf(const aSet: TSet<T>): Boolean;
begin
  Result :=
    (Self.ItemCount <= aSet.ItemCount) and
    aSet.Contains(Self);
end;

// SubsetOf (Left <= Right)
class operator TSet<T>.LessThanOrEqual(const aSet: TSet<T>; aValue: T): Boolean;
begin
  Result := aSet.SubsetOf(aValue);
end;

class operator TSet<T>.LessThanOrEqual(const aSet: TSet<T>; aTArr: TArray<T>): Boolean;
begin
  Result := aSet.SubsetOf(aTArr,True);
end;

class operator TSet<T>.LessThanOrEqual(const aSetLeft,aSetRight: TSet<T>): Boolean;
begin
  Result := aSetLeft.SubsetOf(aSetRight);
end;

// Self >= aSet
function TSet<T>.SupersetOf(const aSet: TSet<T>): Boolean;
begin
  Result :=
    (Self.ItemCount >= aSet.ItemCount) and
    Self.Contains(aSet);
end;

function TSet<T>.SupersetOf(aValue: T): Boolean;
begin
  Result := (Self.ItemCount >= 1) and Self.Contains(aValue);
end;

function TSet<T>.SupersetOf(const aTArr: array of T; checkDuplicates: Boolean = False): Boolean;
begin
  Result := SupersetOf(TSet<T>.Create(aTArr,checkDuplicates));
end;

function TSet<T>.SupersetOf(const aTArr: TArray<T>; checkDuplicates: Boolean = False): Boolean;
begin
  Result := SupersetOf(TSet<T>.Create(aTArr,checkDuplicates));
end;

// SupersetOf (Left >= Right)
class operator TSet<T>.GreaterThanOrEqual(const aSet: TSet<T>; aValue: T): Boolean;
begin
  Result := aSet.SupersetOf(aValue);
end;

class operator TSet<T>.GreaterThanOrEqual(const aSet: TSet<T>; aTArr: TArray<T>): Boolean;
begin
  Result := aSet.SupersetOf(aTArr,True);
end;

class operator TSet<T>.GreaterThanOrEqual(const aSetLeft,aSetRight: TSet<T>): Boolean;
begin
  Result := aSetLeft.SupersetOf(aSetRight);
end;

// A xor B; A=[1,2,3]; B=[2,3,4]; (A+B)-A.Intersect(B) = [1,4] alt:
function TSet<T>.SymmetricDiff(aValue: T): TSet<T>;
begin
  Result := Self;
  Result.Include(aValue);
  Result.Exclude(Self.Intersect(aValue));
  Result.SetSorted(False);
end;

function TSet<T>.SymmetricDiff(const aTArr: TArray<T>): TSet<T>;
begin
  Result := Self;
  Result.Include(aTArr);
  Result.Exclude(Self.Intersect(aTArr));
  Result.SetSorted(False);
end;

function TSet<T>.SymmetricDiff(const aTArr: array of T): TSet<T>;
begin
  Result := Self;
  Result.Include(aTArr);
  Result.Exclude(Self.Intersect(aTArr));
  Result.SetSorted(False);
end;

function TSet<T>.SymmetricDiff(const aSet: TSet<T>): TSet<T>;
begin
  Result:= Self;
  Result.Include(aSet);
  Result.Exclude(Self.Intersect(aSet));
  Result.SetSorted(False);
end;

class operator TSet<T>.LogicalXor(const aSet: TSet<T>; aValue: T): TSet<T>;
begin
  Result := aSet.SymmetricDiff(aValue);
end;

class operator TSet<T>.LogicalXor(const aSet: TSet<T>; aTArr: TArray<T>): TSet<T>;
begin
  Result := aSet.SymmetricDiff(aTArr);
end;

class operator TSet<T>.LogicalXor(const aSet1,aSet2 : TSet<T>): TSet<T>;
begin
  Result := aSet1.SymmetricDiff(aSet2);
end;

procedure TSet<T>.Sort;
begin
  SetLength(Self.FSetArray,Length(Self.FSetArray)); // Ensure COW
  TArray.Sort<T>(Self.FSetArray);
  SetSorted(True);
end;

function TSet<T>.Search(aValue: T): Boolean;
var
  Index: Integer;
begin
  Result := TArray.BinarySearch<T>(Self.FSetArray,aValue,Index);
end;

function TSet<T>.GetSorted: Boolean;
begin
  Result := (FSorted = '1');
end;

procedure TSet<T>.SetSorted(sorted: Boolean);
begin
  if sorted then
    FSorted := '1'
  else
    FSorted := '0';
end;

end.

基准：

program ProjectGenericSet;

{$APPTYPE CONSOLE}

uses
  System.Diagnostics,
  System.Generics.Defaults,
  System.Generics.Collections,
  GenericSet in 'GenericSet.pas';

var
  set1,set2,set3 : TSet<Word>;
  sw : TStopWatch;
  ok : Boolean;
  i,j,max: Integer;
begin
  Randomize;
  max := $10000;
  // Populate a sample set with 32K items.
  repeat
    set1.Include(Random(max));
  until (set1.ItemCount = (max DIV 2));
  // Populate a test set with items in sample set
  repeat
    set2.Include(set1[Random(max DIV 2)]);
  until (set2.ItemCount = 100);
  WriteLn('Test in Sample (unsorted), 1.000 iterations...');
  sw := TStopWatch.StartNew;
  for i  := 1 TO 1000 DO
    ok := set1.Contains(set2);
  sw.Stop;
  WriteLn('Result:',ok,' ',sw.ElapsedMilliseconds,' [ms]');
  set1.Sort; // Sort
  WriteLn('Test in Sample (sorted), 200.000 iterations...');
  sw := TStopWatch.StartNew;
  for i  := 1 TO 200000 DO
  begin
    ok := set1.Contains(set2);
  end;
  sw.Stop;
  WriteLn('Result:',ok,' ',sw.ElapsedMilliseconds,' [ms]');
  WriteLn('Test*Test (unsorted), 200.000 iterations...');
  sw := TStopWatch.StartNew;
  for i  := 1 TO 200000 DO
  begin
    set3 := set2.Intersect(set2);
  end;
  sw.Stop;
  WriteLn('Result:',set3=set2,' ',sw.ElapsedMilliseconds,' [ms]');
  set2.Sort;
  WriteLn('Test*Test (sorted), 200.000 iterations...');
  sw := TStopWatch.StartNew;
  for i  := 1 TO 200000 DO
  begin
    set3 := set2.Intersect(set2);
  end;
  sw.Stop;
  WriteLn('Result:',set3=set2,' ',sw.ElapsedMilliseconds,' [ms]');
  ReadLn;
end.

Answer 2

你在这里处理多对多的关系如果它是一个数据库，意味着你要放入3个表：

1. People
2. Colors
3. Link table between 1 and 2

我建议你通过利用数据库来修复问题，或者在Delphi中模拟数据库中的东西。

使用Delphi结构
此外，停止使用shortstring它们已经过时，并且在长绳上没有任何好处使用3个表意味着您可以快速获得每人的每种颜色和颜色的人员列表。

以下是它的工作原理：

TPerson = record
  name: string;
  other_data....
end;

TPeople = array of TPerson;

TFavColor = record
  name: string;
  other_data....
end;

TFavColors = array of TFavColor;

TPersonColor = record
  PersonIndex: Cardinal;  <<-- index into the TPeople array
  ColorIndex: Cardinal;   <<-- index into the TFavColors array
end;

TPersonColors = array of TPersonColor;

现在，您可以循环遍历TPersonColors数组以提取数据。

使用数据库
在SQL中，它会更快，因为您的数据已被索引（外键（应该）始终被索引）。

SQL语句看到所有喜欢蓝色和红色的人看起来像（在这里使用MySQL语法）：

SELECT p.name  
FROM person p
INNER JOIN personcolor pc ON (pc.person_id = p.id)
INNER JOIN color c1 ON (pc.color_id = c1.id)
INNER JOIN color c2 ON (pc.color_id = c2.id)
WHERE c1.name = 'red' AND c2.name = 'blue'
GROUP BY p.id <<-- eliminate duplicates (not sure it's needed)

使用Delphi将数据库链接到您的应用程序这就是我推荐的路线。

查找两个数组中的公共元素

2 个答案: