7
votes

Ce qui est plus rapide dans la recherche d'élément avec une propriété de valeur maximale

Communément, pour trouver l'élément avec la propriété de la valeur max, je ressemble à ce xxx

mais est-il bon du point de vue de la performance? Peut-être que je devrais faire quelque chose comme ça? xxx

performance c# linq collections

3 commentaires

Je vais avec max car il est spécialement conçu pour cela ... Tri pour trouver la valeur maximale semble être trop ... aussi, je n'utiliserais pas où Pour trouver le maximum, mais unique


                                        
                                                                             orderbydescendants  / rapide doit être O (n ^ 2) et  max  est O (n) avec  où  O (n) - donc la seconde approche devrait être plus rapide

                                        
                                                                            Voir  Nuget.org/packages/morelinq.source.moreenumerable.Maxby Pour une utilisation en mémoire (ne se traduit pas sur SQL)



                                    
                    4 Réponses :
                    
                                            
                            
                                
                                    4
 votes
                                
                            
                            
                                
                                     Je vais aller avec  max  car il est spécifiquement conçu à cet effet. Le tri pour trouver  max  la valeur semble être trop. 
 Aussi, je n'utiliserais pas  où  pour trouver le maximum, mais  unique  - Depuis ce que nous avons besoin ici, c'est un  Single  .   xxx  
 ou à l'aide de  d'abord  (si la collection contient des doublons de valeur max)   xxx  > Ou, en utilisant  Morelinq  (comme suggéré par kathi ), vous pouvez le faire avec  maxby :   xxx  
 vérifier ceci  post , sur réponse par  Skeet Jon .                                  


                                                                    
                                    
                                    
                                        8 commentaires
                                        
                                                                                            
                                                    Vous voudrez peut-être utiliser  d'abord  au lieu de  unique  si la collection contient plus d'un élément (dont la valeur maximale de la propriété) et op ne se soucie pas de laquelle une prendre dans ce cas.                                                

                                                
                                                                                            
                                                    @Yacoubmassad Vous avez raison, cela est certainement une alternative valable.                                                
                                                
                                                                                            
                                                    Veuillez noter également que si vous combinez les deux lignes, alors  collection.max (x => x.property)  peut être évalué plusieurs fois.                                                

                                                
                                                                                            
                                                    @Kathi Vous voulez dire ceci:  msdn.microsoft.com/en-us/library/... ? Il semble que ce ne soit pas typique Linq, je ne suis pas sûr de sa performance ...                                                
                                                
                                                                                            
                                                    @Ian si c'est Morelinq, alors c'est ce que je voulais dire mais aussi vérifier cela:  Stackoverflow.com/a/1101931/5210934 , vous trouverez le  maxby (..)  chose aussi dans une réponse là-bas                                                

                                                
                                                                                            
                                                    @Kathi Ok, je pose l'alternative, faisant référence à vous. ;) Il semble être une bonne solution. Merci de le pointer.                                                
                                                
                                                                                            
                                                    @Ian mathématiquement, la solution d'agrégat semble être la meilleure que vous ne traverserez que la liste une fois ..                                                
                                                
                                                                                            
                                                    @Kathi ignorant tous les autres retards causés par elle, alors cela pourrait probablement être. ;) Seulement un peu plus compliqué à voir ...                                                
                                                
                                                                                    

                                    

                                                            

                        

                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     L'élément maximum sous une fonction spécifiée peut également être trouvé au moyen des deux fonctions suivantes. 
static class Tools
{
    public static T ArgMax<T, R>(T t1, T t2, Func<T, R> f)
    where R : IComparable<R>
    {
        return f(t1).CompareTo(f(t2)) > 0 ? t1 : t2;
    }

    public static T ArgMax<T, R>(this IEnumerable<T> Seq, Func<T, R> f)
    where R : IComparable<R>
    {
        return Seq.Aggregate((t1, t2) => ArgMax<T, R>(t1, t2, f));
    }
}

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    4
 votes
                                
                            
                            
                                
                                     Les deux solutions ne sont pas très efficaces. La première solution consiste à trier toute la collection. La deuxième solution nécessite une collecte de traversée deux fois. Mais vous pouvez trouver un article avec une valeur de propriété maximale en une fois sans tri. Il y a une extension maxby dans  bibliothèque Morelinq . Ou vous pouvez implémenter la même fonctionnalité: 
var itemWithMaxPropValue = collection.MaxBy(x => x.Property); 

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    5
 votes
                                
                            
                            
                                
                                     Le tri est  n * journal (n)  code> tandis que max a  n  code> la seule complexité de temps, donc  max  code> est  plus vite  em >. Ce que vous cherchez, c'est  argmax  code> fonction que  linq  em> ne fournit pas, donc je suggère de la mettre en œuvre, par exemple: 
  var itemWithMaxPropValue = collection
    .ArgMax(x => x.Property);

                                

                                                                    
                                    
                                    
                                        0 commentaires