C # equivalente de std :: sort y std :: unique

Question

Tengo una lista de enteros en C #. Deseo eliminar duplicados. En C ++ lo ejecutaría a través de los algoritmos std :: sort y luego std :: unique para una forma muy eficiente de obtener la lista única.

¿Cuál es la mejor manera de hacer lo mismo en C #? En otras palabras, estoy buscando una forma más elegante de hacer el siguiente código:

    private static int[] unique(int[] ids)
    {
        IDictionary<int, object> d = new Dictionary<int, object>();
        foreach(int i in ids)
            d[i] = null;

        int[] results = new int[d.Count];
        int j = 0;
        foreach(int id in d.Keys)
            results[j++] = id;

        return results;
    }

Answer 1

¿Qué versión de .NET estás usando?

En .NET 3.5 eso es tan simple como llamar al Distinct () método de extensión y luego ToArray () si Realmente necesitas una matriz de nuevo.

Por ejemplo:

int[] x = new[] { 1, 4, 23, 4, 1 };
int[] distinct = x.Distinct().ToArray();
// distinct is now { 1, 4, 23 } (but not necessarily in that order)

Answer 2

si considera los métodos STL como "muy eficientes", utilice lo siguiente:

       var vals = new List<int> { 1, 2, 3, 2, 1, 2, 3, 2, 3, 4, 3, 2, 3 };
       vals.Sort();
       var uniques = new HashSet<int>(vals);

Para el equivalente 2.0

List<int> vals = new List<int>();
vals.Add(1);
vals.Add(2);
vals.Add(3);
vals.Add(2);
...
vals.Sort();
List<int> uniques = new List<int>();
vals.ForEach(delegate(int v) {
 if (!uniques.Contains(v)) uniques.Add(v);
});

Answer 3

Incluso con .NET 2.0, puede obtener lo mismo con LINQBridge . Esto será más fácil de usar con C # 3.0 (incluso con .NET 2.0), pero debería poder usarse con C # 2.0 y .NET 2.0: simplemente tendría que usar Enumerable.Distinct (x) en lugar de x.Distinct ();

Por supuesto, en última instancia, estas son solo versiones preempaquetadas del código que publicó anteriormente (cosas de dar o recibir como bloques iteradores), por lo que podría insertar ese código en una clase de utilidad y (re) usarlo desde allí.

Answer 4

Por desgracia, solo tengo .NET 2.0 para trabajar

Answer 5

En una nota relacionada a mitad de camino, C # tiene un Método estático System.Array.Sort que puede usar para ordenar matrices reales sin usar una colección.

Answer 6

No sé qué tan grande es su colección, pero si no está tratando con miles de enteros, esto podría ser lo suficientemente bueno:

public IEnumerable<int> unique(int[] ids)
{
    List<int> l = new List<int>();
    foreach (int id in ids)
    {
        if (!l.Contains(id))
        {
            l.Add(id);
            yield return id;
        }
    }
}

Answer 7

  private static List<T> GetUnique<T>(List<T> list) where T : IEquatable<T>
  {
     list.Sort();
     int count = list.Count;
     List<T> unique = new List<T>(count);
     T last = default(T);
     for (int i = 0; i < count; i++)
     {
        T val = list[i];
        if (i != 0 && last.Equals(val)) continue;
        last = val;
        unique.Add(val);
     }
     return unique;
  }