迭代时从哈希集中删除

Question

I have the following code:

       List<HashSet<String>> authorLists = new List<HashSet<String>>
       // fill it
        /** Remove duplicate authors  */
        private void removeDublicateAuthors(HashSet<String> newAuthors, int curLevel)
        {

            for (int i = curLevel - 1; i > 0; --i)
            {
                HashSet<String> authors = authorLists[i];
                foreach (String item in newAuthors)
                {
                    if (authors.Contains(item))
                    {
                        newCoauthors.Remove(item);
                    }
                }
            }
        }

How to remove items correctly? I need to iterate through newAuthors and authorLists. RemoveWhere cannot be used here by this reason.

It is very inefficient to create new list, add items to them and then remove duplicate items. In my case, list of authorLists has following sizes:

authorLists [0].size = 0;
authorLists [1].size = 322;
authorLists [2].size = 75000; // (even more than this value)

I need to call removeDublicateAuthors 1*(1) 322 (n) 75000 (m) times where n and m are the sizes of duplicate authors on the 1st and 2nd levels correspondingly. I have to delete these items very often and the size of array is very large. So, this algorithm is very inefficient. Actually I have the following code in Java and to rewrite it by some reasons:

/** Remove duplicate authors in tree of Authors*/

private void removeDublicateAuthors(HashSet<String> newCoauthors, int curLevel ) {

for(int i = curLevel - 1; i > 0; --i) {
    HashSet<String> authors = coauthorLevels.get(i);
    for (Iterator<String> iter = newCoauthors.iterator(); iter.hasNext();) {
        iter.next();
        if(authors.contains(iter)) {
            iter.remove();
        }
    }
}
}

It works much faster than suggested options at the moment

Answer 1

您可以将要删除的项目添加到另一个哈希集中，然后将其全部删除。

Answer 2

What you are doing here is wrong because of 2 reasons: 1. you cannot alter a set you are parsing through - sintax problem 2. even if you make your code work, you will only alter the value, not the reference - logic problem

   List<HashSet<String>> authorLists = new List<HashSet<String>>
   // fill it
   /** Remove duplicate authors  */
   // handle reference instead of value
   private void removeDublicateAuthors(ref HashSet<String> newAuthors, int curLevel)
   {
       List<string> removeAuthors = new List<string>();

       for (int i = curLevel - 1; i > 0; --i)
       {
           HashSet<String> authors = authorLists[i];
           foreach (String item in newAuthors)
           {
               if (authors.Contains(item))
               {
                   removeAuthors .Add(item);
               }
           }
       }

       foreach(string author in removeAuthors)
       {
           newAuthors.Remove(author);
       }
   }

Answer 3

What you're looking for is ExceptWith . You're trying to find the set of one set subtracted from another, which is exactly what that method does.

Answer 4

Forgive me if I don't understand what you are trying to do.

Hash sets don't allow duplicates because the index of an item is the hash of the item. Two equal strings would have the same hash, and therefore the same index. Therefore if you simply combine any two hash sets, the result is free from duplicates.

Consider the following:

        var set1 = new HashSet<string>();
        set1.Add("foo");
        set1.Add("foo");

        var set2 = new HashSet<string>();
        set2.Add("foo");

        var set3 = set1.Union(set2);

        foreach (var val in set3)
        {
          Console.WriteLine(val);   
        }

The output of this code would be:

foo

Now if you are trying to ensure that hashset A doesn't include any items in hashset B, you could do something like this:

        var set1 = new HashSet<string>();
        set1.Add("foo");
        set1.Add("bar");

        var set2 = new HashSet<string>();
        set2.Add("foo");
        set2.Add("baz");

        foreach (var val in set2)
        {
            set1.Remove(val);
        }

        foreach (var val in set1)
        {
            Console.WriteLine(val);    
        }

The output of which would be:

bar

Giving this some more thought, you can subtract one set from another using the .Except method.

var set3 = set1.Except(set2);

This produces all the items in set1 that are not in set2