buscar duplicados en la lista de arrays

Question

Tengo una lista de matrices que contiene elementos llamados Sala. Cada habitación tiene un tipo de habitación, como cocina, recepción, etc. Quiero verificar la lista de arrays para ver si existen habitaciones de ese tipo antes de agregarlas a la lista. ¿Alguien puede recomendar una forma ordenada de hacerlo sin la necesidad de múltiples bucles foreach?

(.NET 2,0)

---

No he acceso a la tecnología LINQ dieron como estoy corriendo en .NET 2.0. Debería haberlo dicho en la pregunta. Disculpas

Answer 1

No utilizaría ArrayList aquí; ya que tiene .NET 2.0, utilice List<T> y todo se vuelve simple:

List<Room> rooms = ... 
string roomType = "lounge"; 
bool exists = rooms.Exists(delegate(Room room) { return room.Type == roomType; }); 

O con C# 3.0 (todavía apuntan a .NET 2,0)

bool exists = rooms.Exists(room => room.Type == roomType); 

O con C# 3.0 y, o bien LINQBridge o .NET 3.5 :

bool exists = rooms.Any(room => room.Type == roomType); 

(el uso Any trabajará con más tipos, no sólo List<T>)

Answer 2

if (!rooms.Any (r => r.RoomType == typeToFind /*kitchen, ...*/)) 
    //add it or whatever 

Answer 3

Pensé en usar listas y hacer Exists en una operación que toma O(n) vez. El uso de Dictionary en su lugar es O(1) y se prefiere si la memoria no es un problema.

Si usted no necesita la lista secuencial Me gustaría probar usando un Dictionary así:

Dictionary<Type, List<Room>> rooms = new Dictionary<Type, List<Room>>; 

void Main(){ 
    KitchenRoom kr = new KitchenRoom(); 
    DummyRoom dr = new DummyRoom(); 
    RoomType1 rt1 = new RoomType1(); 
    ... 

    AddRoom(kr); 
    AddRoom(dr); 
    AddRoom(rt1); 
    ... 

} 

void AddRoom(Room r){ 
    Type roomtype = r.GetType(); 
    if(!rooms.ContainsKey(roomtype){ //If the type is new, then add it with an empty list 
    rooms.Add(roomtype, new List<Room>); 
    } 
    //And of course add the room. 
    rooms[roomtype].Add(r); 
} 

Es, básicamente, tiene una lista de diferentes tipos de habitación. Pero esta solución solo está bien si no necesita el arraylist. Pero para listas grandes, esta será la más rápida.

Tuve una solución una vez con List<string> con más de 300,000 elementos. Comparar cada elemento con otra lista de casi el mismo tamaño tomó 12 horas para hacer. Cambió la lógica a usar Diccionario en su lugar y hasta 12 minutos. Para listas más grandes siempre voy al Dictionary<mytype, bool> donde bool es solo un maniquí que no se usa.

Answer 4

Sin usar expresiones lambda:

void AddRoom(Room r, IList<Room> rooms, IDictionary<string, bool> roomTypes) 
{ 
    if (!roomTypes.Contains(r.RoomType)) 
    { 
     rooms.Add(r); 
     roomTypes.Add(r.RoomType, true); 
    } 
} 

En realidad, no importa cuál sea el tipo del valor en el diccionario es, ya que la única cosa que siempre está viendo es las llaves.

Answer 5

Otra forma es ordenar la matriz, luego recorrer los elementos hasta encontrar un par de duplicados adyacentes. Hazlo hasta el final, y la matriz está libre de engaños.

Answer 6

De su pregunta no es 100% claro para mí si desea hacer cumplir la regla de que puede haber solo una habitación de un tipo dado, o si simplemente desea saber.

Si tiene el invariante que ninguna colección de Room s puede tener más de uno del mismo tipo Room, es posible que trate de usar un Dictionary<Type, Room>.

Esto tiene el beneficio de no realizar una búsqueda lineal al agregar.

deberá añadir una habitación utilizando las siguientes operaciones:

if(rooms.ContainsKey(room.GetType())) 
{ 
    // Can't add a second room of the same type 
    ... 
} 
else 
{ 
    rooms.Add(room.GetType(), room); 
}