Question

我有两个列表如下

var topicsA = new List<Topic>()
{
    new Topic(){ TopicCode = "T01", TopicAccessed = false },
    new Topic(){ TopicCode = "T02", TopicAccessed = false },
    new Topic(){ TopicCode = "T03", TopicAccessed = false }
};

var topicsB = new List<Topic>()
{
    new Topic(){ TopicCode = "T01"},
    new Topic(){ TopicCode = "T02"}
};

什么是将TopicAccessed的{{1}}值设置为true的快速方法，其中topicsA的属性值在topicsB中相同

例如，在这种情况下，TopicCode和T01会将T02设置为true

此致

Answer 1

所有答案都显示二次算法复杂度（Big O）。此代码段显示线性大O：

var accessedTopicsByCode = topicsB.ToDictionary(x => x.TopicCode);
foreach (var t in topicsA)
{
    if (accessedTopicsByCode.ContainsKey(t.TopicCode))
    {
        t.TopicAccessed = true;
    }
}

Answer 2

使用词典获得更好的表现：

var hash = new Dictionary<string,bool>();

foreach(var topicB in topicsB)
{
    hash[topicB.TopicCode] = true;
}

foreach(var topicA in topicsA)
{
    topicA.TopicAccessed = hash.ContainsKey(topicA.TopicCode);
}

该解决方案的复杂性为O（n + m），而嵌套循环为O（n * m）。 ContainsKey的复杂性是O（1）

或者你也可以使用HashSet，因为我们只需要键，而不是值：

var hash = new HashSet<string>();

foreach(var topicB in topicsB)
{
    hash.Add(topicB.TopicCode);
}

foreach(var topicA in topicsA)
{
        topicA.TopicAccessed = hash.Contains(topicA.TopicCode);
}

这与使用Dictionary有相同的复杂性，但它在内存使用方面更有效。 Contains'复杂性为O（1）

Answer 3

您可以尝试这样的事情：

// We iterate though the items of topicsA list.
foreach(var topicA in topicsA)
{
    // If topicsB list contains any item with the same TopicCode like 
    // the current's item TopicCode, update the TopicAccessed.
    if(topicsB.Any(x=>x.TopicCode == topicaA.TopicCode))
    {
        topicA.TopicAccessed = true;
    }
}

检查两个列表包含相同的属性值

3 个答案: