C# 嵌套while循环替代方案

我写了一些代码，遵循下面的基本模式。我想看看是否有更好、更简洁或更好的想法来实现它的目标。目标是将一个列表中的项目与另一个列表中的项目进行比较，如果它们匹配，则执行操作。我让它工作的唯一方法是下面的想法，但我对c#和.net还不熟悉，不确定是否有更好的方法

list A
list B
int counter;
int counter2;
while (counter < comparison item)
{
    while (counter2 < comparison item 2)
    {
        if (A[counter] == B[counter2])
        {
            // do stuff
        }
        counter2++;
    }
    counter++;
}

列表A
名单B
整数计数器；
int计数器2；
while（计数器<比较项目）
{
而（计数器2<比较项目2）
{
如果（A[计数器]==B[计数器2]）
{
//做事
}
计数器2++；
}
计数器++；
}

如果不需要更改列表，则应使用

foreach

循环

foreach (var itemA in A)
{
    foreach (var itemB in B)
    {
        if (itemA == itemB) {}
    }
}

for (var i = 0; i < A.Count; i++) 
{
    for (var j = 0; j < B.Count; j++)
    {
        if (A[i] == B[j]) {}
    }
}

如果确实需要更改列表，则应使用

for

循环

foreach (var itemA in A)
{
    foreach (var itemB in B)
    {
        if (itemA == itemB) {}
    }
}

for (var i = 0; i < A.Count; i++) 
{
    for (var j = 0; j < B.Count; j++)
    {
        if (A[i] == B[j]) {}
    }
}

for（变量i=0；i

如果对两个列表进行排序，则可以通过按顺序浏览列表来更有效地进行排序

int i = 0;
int j = 0;

while (A.Length <= i && B.Length <= j)
{
    if (A[i] == B[j]) 
    {
        // items are equal
        i++;
        j++;
    }
    else if (A[i] > B[j]) // Comparison of the ordered value, could be a property on the item.
    {
        j++; // increment B's counter
    }
    else
    {
        i++; // increment A's counter
    }
}

inti=0；
int j=0；
而（A.Length如果不需要更改列表，则应使用
foreach
循环

foreach (var itemA in A)
{
    foreach (var itemB in B)
    {
        if (itemA == itemB) {}
    }
}

for (var i = 0; i < A.Count; i++) 
{
    for (var j = 0; j < B.Count; j++)
    {
        if (A[i] == B[j]) {}
    }
}

如果确实需要更改列表，则应使用
for
循环

foreach (var itemA in A)
{
    foreach (var itemB in B)
    {
        if (itemA == itemB) {}
    }
}

for (var i = 0; i < A.Count; i++) 
{
    for (var j = 0; j < B.Count; j++)
    {
        if (A[i] == B[j]) {}
    }
}

for（变量i=0；i

如果对两个列表进行排序，则可以通过按顺序浏览列表来更有效地进行排序

int i = 0;
int j = 0;

while (A.Length <= i && B.Length <= j)
{
    if (A[i] == B[j]) 
    {
        // items are equal
        i++;
        j++;
    }
    else if (A[i] > B[j]) // Comparison of the ordered value, could be a property on the item.
    {
        j++; // increment B's counter
    }
    else
    {
        i++; // increment A's counter
    }
}

inti=0；
int j=0；
虽然（A.Length这两个循环结构很简单，但它没有性能。问题是比较的数量：如果第一组有
N
项，第二组有
M
，那么将有
N*M
项比较。每组有1000项，我们谈论的是1000000项比较

更好的方法是对第一个集合的项目进行散列，然后从第二个集合中搜索散列中的项目。由于散列是在摊销的固定时间内完成的，因此可以在
M+N
操作中完成，或者对两个集合（每组1000个项目）进行大约2000次：

var setA = new HashSet<int>(listA);
foreach (var b in listB) {
    if (setA.Contains(b)) {
        ...
    }
}

这两个循环结构很简单，但性能不好。问题是比较的数量：如果第一组有
N
项，第二组有
M
，那么会有
N*M
项比较。每组有1000项，我们说的是1000000项比较

更好的方法是对第一个集合的项目进行散列，然后从第二个集合中搜索散列中的项目。由于散列是在摊销的固定时间内完成的，因此可以在
M+N
操作中完成，或者对两个集合（每组1000个项目）进行大约2000次：

var setA = new HashSet<int>(listA);
foreach (var b in listB) {
    if (setA.Contains(b)) {
        ...
    }
}

LINQ是一种可能性，但在功能上是相同的。您也可以事先对列表进行排序，并执行合并联接类型操作。根据列表的大小和计划执行的操作类型，它可能会更快。与往常一样，measure.LINQ是一种可能性，但在功能上是相同的。您也可以提前对列表进行排序ehand并执行合并联接类型操作。根据列表的大小和您计划执行的操作类型，它可能会更快。一如既往，请测量。感谢您的回答，对于第二个示例，您会将列表用作列表对象还是哈希集对象？@wondergoat77传递到LINQ的容器并不重要。它使用内部使用基于哈希的容器进行合并，将输入视为
IEnumerable
。感谢您的回答，对于第二个示例，您是将列表用作列表对象还是哈希集对象？@wondergoat77传递给LINQ的容器无关紧要：它在内部使用基于哈希的容器进行合并，将他输入为
IEnumerable
。