Perl: trier un hachage par valeur, par clé

Question

similaire à cette question: sort by subset of perl string

Je voudrais d'abord trier par valeur, puis par sous-ensemble de la clé.

mon hachage%

cat_02 => 0 
cat_04 => 1 
cat_03 => 0 
cat_01 => 3 

la sortie: (pourrait être un tableau des clés dans cet ordre)

cat_02 => 0 
cat_03 => 0 
cat_04 => 1 
cat_01 => 3 

Bonus: la comparaison secondaire clé reconnaîtrait 1234_2_C01 et étant plus petite que 1234_34_C01 (cmp ne fonctionne pas)

Answer 1

my %hash = (
    cat_02 => 0, 
    cat_04 => 1, 
    cat_03 => 0, 
    cat_01 => 3 
); 

print "$_ => $hash{$_}\n" 
    for sort { $hash{$a} <=> $hash{$b} or $a cmp $b } keys %hash; 

Le tri fait la comparaison numérique des valeurs, et si elles ' re égal, la partie après le or est exécutée, ce qui fait la comparaison de chaîne des clés. Cela donne la sortie que vous avez demandée.

Pour le tri intelligent des chaînes qui contiennent des nombres mélangés avec des choses non-numérique, saisir la fonction de comparaison de Alphanum de http://www.davekoelle.com/alphanum.html et remplacer $a cmp $b avec alphanum($a,$b)

Answer 2

Lorsque vous avez une préférence de tri secondaire, vous ajoutez simplement un autre niveau à l'intérieur du sorte de routine:

my %hash = (
    cat_02 => 0, 
    cat_04 => 1, 
    cat_03 => 0, 
    cat_01 => 3 
); 

my @sorted = sort { $hash{$a} <=> $hash{$b} || $a cmp $b } keys %hash; 
        # primary sort method ^^ secondary sort method 
for (@sorted) { 
    print "$_\t=> $hash{$_}\n"; 
} 

sortie:

cat_02 => 0 
cat_03 => 0 
cat_04 => 1 
cat_01 => 3 

Answer 3

Cela peut ne pas valoir la peine dans ce cas particulier, mais la technique Schwartzian transform peut aussi être utilisée avec le tri multi-critères. Comme cela (codepad):

use warnings; 
use strict; 

my %myhash = (
    cat_2 => 0, cat_04 => 1, 
    cat_03 => 0, dog_02 => 3, 
    cat_10 => 0, cat_01 => 3, 
); 

my @sorted = 
    map { [$_->[0], $myhash{$_->[0]}] } 
    sort { $a->[1] <=> $b->[1] or $a->[2] <=> $b->[2] } 
    map { m/([0-9]+)$/ && [$_, $myhash{$_}, $1] } 
    keys %myhash; 

print $_->[0] . ' => ' . $_->[1] . "\n" for @sorted; 

De toute évidence, la clé de cette technique est d'utiliser plus d'un élément supplémentaire dans le cache. Deux choses ici: 1) @sorted devient en fait un tableau de tableaux (chaque élément de ce tableau est une paire clé-valeur); 2) le tri dans cet exemple est basé sur le suffixe des chiffres des touches (avec une comparaison numérique, pas une chaîne), mais il peut être ajusté dans n'importe quelle direction si nécessaire.

Par exemple, lorsque les touches modèle de correspondance XXX_DD_XXX (et il est DD qui doit être comparé), changer la deuxième map clause avec ceci:

map { m/_([0-9]+)_/ && [$_, $myhash{$_}, $1] } 

Answer 4

Cela peut facilement être fait (rapidement!) En utilisant le Tri: : Key :: modules:

use Sort::Key::Natural qw(); 
use Sort::Key::Maker intnatkeysort => qw(integer natural); 

my @sorted_keys = intnatkeysort { $hash{$_}, $_ } keys(%hash); 

Ou vous pouvez profiter des propriétés de vos données et il suffit d'utiliser une sorte naturelle:

use Sort::Key::Natural qw(natkeysort); 

my @sorted_keys = natkeysort { "$hash{$_}-$_" } keys(%hash); 

• Sort::Key::Natural
• Sort::Key::Maker