¿Hay una colección genérica de lista ordenada sin clave única en C#?

sortedlist en c#

Question

Estoy un poco sorprendido por System.Collections.Generic.SortedList, en eso

1. Requiere que use <key, value> lugar de <value> (comparador)
2. Solo se permite en entrada por valor.

Esto parece extraño en la forma en que quiero usarlo (aunque estoy seguro de que son perfectos para otras situaciones). ¿Hay otra colección que no tenga estas dos características?

Answer 1

Intenté encontrar lo mismo: básicamente una lista que permanece ordenada a medida que le agregas elementos. Lo más cercano que he encontrado hasta ahora es un SortedSet de Goletas.Collections, que usa una implementación de árbol AVL:

http://www.goletas.com/solutions/collections/

Pero esta clase aún requiere que cada elemento de la lista sea único (por lo tanto, "Conjunto").

Quizás esta clase podría modificarse para admitir elementos no únicos.

Answer 2

No estoy seguro de si esto cumplirá con sus requisitos. Pero puedes ordenar una lista normal. MSDN habla de ello, pero obviamente esto requiere una ordenación de llamada.

Answer 3

Sé que esta es una pregunta antigua, pero acabo de encontrar esta otra pregunta ( colección C # Sortable que permite duplicar claves ), que ofrece una solución: ¡Use su propio IComparer con un SortedSet! Es decir

/// <summary>
/// Comparer for comparing two keys, handling equality as being greater
/// Use this Comparer e.g. with SortedSets, SortedLists or SortedDictionaries, that don''t allow duplicate keys
/// </summary>
/// <typeparam name="TKey"></typeparam>
public class DuplicateKeyComparer<TKey> : IComparer<TKey> where TKey : IComparable
{
    #region IComparer<TKey> Members

    public int Compare(TKey x, TKey y)
    {
        int result = x.CompareTo(y);

        return result == 0 ? 1 : result; // Handle equality as being greater
    }

    #endregion
}

Uso:

SortedSet<T> mySortedValues = new SortedSet<T>(new DuplicateKeyComparer<T>());

Edición: SortedSet<T> , esta es probablemente una mala idea para cualquier otra cosa que no sea SortedSet<T> ya que probablemente no sería capaz de buscar los diferentes valores asociados con las claves duplicadas utilizando algo que no sea un bucle foreach ; y SortedSet<T> estaría mejor representado por SortedList<TKey,TValue> con el valor de TKey como valor interesante y el valor de TValue es un conteo (por ejemplo, int ) del número de duplicados de ese objeto.

Answer 4

Si no es crítico para el rendimiento, puede usar cualquiera

1) Linq OrderBy () o

2) Método de lista Ordenar ()

Ver este ejemplo

        var list = new List<int>();
        list.Add( 2);
        list.Add( 1);
        list.Add( 3);

        Console.WriteLine("Using Linq OrderBy");
        foreach (int i in list.OrderBy(i=>i))
            Console.WriteLine(i);

        Console.WriteLine("Using List.Sort()");
        list.Sort();
        foreach (int i in list)
            Console.WriteLine(i);

Answer 5

SortedList<,> es realmente un mapa ordenado por clave, no una lista. Mal nombre, tal vez. Pero hay formas de emular lo que desea, dependiendo de sus requisitos exactos. Podría, por ejemplo, encapsular una lista SortedList<T, int> y agregar / eliminar algo como:

// add
int count;
if(list.TryGetValue(value, out count)) list[value] = count+1;
else list[value] = 1;

En última instancia, también podría usar una lista simple ( List<> ), depende de lo que esté haciendo.

En parte, espero que el enlace de datos, etc., dificulte la implementación de una lista regular que se clasifique de inmediato: es necesario implementar muchas interfaces para que funcione, ya que normalmente se espera que el elemento que agregue permanezca al final.