基于插入顺序对散列进行迭代？ [英] Iterating hash based on the insertion order?
本文介绍了基于插入顺序对散列进行迭代？的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
使用此命令并不会保留订单。
foreach my $ val（keys％hash）{
...
}
解决方案
哈希默认在Perl 5中是无序的。您可以使用 tie 和 Tie :: IxHash 来覆盖此行为。不过要注意的是，有性能问题和其他考虑因素（例如订单不会保留在副本中）。
＃！/ usr / bin / perl
use strict;
使用警告;
使用Tie :: IxHash;
绑定我的％散列，Tie :: IxHash
或者死掉无法绑定％hash;
$ hash {one} = 1;
$ hash {two} = 2;
$ hash {three} = 3;
for my $ k（keys％hash）{
print$ k $ hash {$ k} \\\
;
}
更好的选择可能是使用散列的数组或散列： / p>
＃！/ usr / bin / perl
use strict;
使用警告;
my％hash;
$ hash {one} = {data => 1，order => 1};
$ hash {three} = {data => 3，order => 2};
$ hash {two} = {data => 2，order => 3};
（$ {$ hash {$ a} {order}< => $ hash {$ b} {order}}键％hash）{
print $ k $ hash {$ k} {data} \\\
;
}
至于性能，以下是基准测试结果：
IndexedOO：a，b，c，d，e，f
HashOrdered：a，b，c，d，e，f
IxHashOO：a，b，c，d，e，f
hash：f，e，a，c，b，d
hoh_pis：a，b，c，d，e， f
IxHash：a，b，c，d，e，f
hoh：a，b，c，d，e，f
索引：a，b，c，d，e ，f
费率IxHash hoh索引IxHashOO索引100 hoh_pis哈希订购散列
IxHash 261 / s - -18％-26％-48％-54％-57％-66％-80％
hoh 316 / s 21％ - -10％-37％-44％-48％-59％-75％
索引353 / s 35％12％ - -29％-38％-42％ - 55％-72％
IxHashOO 499 / s 91％58％41％ - -12％-18％-36％-61％
指数100 569 / s 118％80％61％14％ - -7％-27％-56％
hoh_pis 611 / s 134％93％73％22％7％ - -21％-52％
Hash订购778 / s 198％146％120％56％37％27％ - -39％
hash 1279 / s 391％305％262％156％125％109％64％ -
由此我们可以看到，如果你不需要它像行为一样使用Hash :: Ordered，正常散列（即一个并列散列）。
以下是基准：
＃！/ usr / bin / perl
use strict;
使用警告;
使用Tie :: IxHash;
使用Tie :: Hash :: Indexed;
使用Hash :: Ordered;
使用基准;
＃这是O（n）而不是O（n log n）或更糟
sub perfect_insert_sort {
my $ h = shift;
my @k;
for $ k（keys％$ h）{
$ k [$ h-> {$ k} {order}] = $ k;
}
return @k;
}
我的@keys = qw / a b c d e f /;
my％subs =（
hash => sub {
my $ i;
my％h = map {$ _ => $ i ++} @keys;
return join，，keys％h;
}，
hoh => sub {
my $ i;
my $ order;
my％ h = map {
$ _ => {data => $ i ++，order => $ order ++}
} @keys;
return join，，sort {$ h {$ a} {order}< => $ h {$ b} {order}}
键％h;
}，
hoh_pis => sub {
my $ i;
my $ order;
my％h = map {
$ _ => {data => $ i ++，order => $ order ++}
} @keys;
return join，，perfect_insert_sort \％h;
}，
IxHash => sub {
my $ i;
tie my ％h，Tie :: IxHash;
％h = map {$ _ => $ i ++} @keys;
返回连接，，键％h;
}，
Indexed => sub {
my $ i;
tie my％h，Tie :: Hash ：：索引;
％h = map {$ _ => $ i ++} @keys;
返回连接，，键％h;
}，
IxHashOO => sub {
my $ i;
my $ o = tie my％h，Tie :: IxHash，
map {$ _ => $ i ++} @keys;
返回连接，，$ o->键;
}，
IndexedOO => sub {
my $ i;
my $ o = tie my％h，Tie :: Hash :: Indexed，
map {$ _ => $ i ++} @keys;
my @k = my $ k = $ o-> FIRSTKEY;
while（$ k = $ o-> NEXTKEY（$ k））{
push @k，$ k;
}
返回连接，，@k;
}，
HashOrdered => sub {
my $ i;
my $ oh = Hash :: Ordered-> new（map {$ _ => $ i ++} @keys）;
返回加入，，$ oh->键;
}，
）;
for my $ sub（keys％subs）{
print$ sub：，$ subs {$ sub}（），\\\
;
}
@keys = 1 .. 1_000;
基准:: cmpthese -2，\％subs;
Don't want to sort the entries.
using this does not preserve the order as well
foreach my $val (keys %hash) {
...
}
解决方案
Hashes are unordered by default in Perl 5. You can use tie and Tie::IxHash to override this behavior. Be warned though, there is a performance hit and other considerations (like the fact that the order will not be preserved in copies).
#!/usr/bin/perl
use strict;
use warnings;
use Tie::IxHash;
tie my %hash, "Tie::IxHash"
or die "could not tie %hash";
$hash{one} = 1;
$hash{two} = 2;
$hash{three} = 3;
for my $k (keys %hash) {
print "$k $hash{$k}\n";
}
A better option may be to use an array or a hash of hashes:
#!/usr/bin/perl
use strict;
use warnings;
my %hash;
$hash{one} = { data => 1, order => 1 };
$hash{three} = { data => 3, order => 2 };
$hash{two} = { data => 2, order => 3 };
for my $k (sort { $hash{$a}{order} <=> $hash{$b}{order} } keys %hash) {
print "$k $hash{$k}{data}\n";
}
As for performance, here are the results of a benchmark:
IndexedOO: a, b, c, d, e, f
HashOrdered: a, b, c, d, e, f
IxHashOO: a, b, c, d, e, f
hash: f, e, a, c, b, d
hoh_pis: a, b, c, d, e, f
IxHash: a, b, c, d, e, f
hoh: a, b, c, d, e, f
Indexed: a, b, c, d, e, f
Rate IxHash hoh Indexed IxHashOO IndexedOO hoh_pis HashOrdered hash
IxHash 261/s -- -18% -26% -48% -54% -57% -66% -80%
hoh 316/s 21% -- -10% -37% -44% -48% -59% -75%
Indexed 353/s 35% 12% -- -29% -38% -42% -55% -72%
IxHashOO 499/s 91% 58% 41% -- -12% -18% -36% -61%
IndexedOO 569/s 118% 80% 61% 14% -- -7% -27% -56%
hoh_pis 611/s 134% 93% 73% 22% 7% -- -21% -52%
HashOrdered 778/s 198% 146% 120% 56% 37% 27% -- -39%
hash 1279/s 391% 305% 262% 156% 125% 109% 64% --
From this we can see that using Hash::Ordered is the way to go if you don't need it to behave like a normal hash (ie a tied hash).
Here is the benchmark:
#!/usr/bin/perl
use strict;
use warnings;
use Tie::IxHash;
use Tie::Hash::Indexed;
use Hash::Ordered;
use Benchmark;
#this is O(n) instead of O(n log n) or worse
sub perfect_insert_sort {
my $h = shift;
my @k;
for my $k (keys %$h) {
$k[$h->{$k}{order}] = $k;
}
return @k;
}
my @keys = qw/a b c d e f/;
my %subs = (
hash => sub {
my $i;
my %h = map { $_ => $i++ } @keys;
return join ", ", keys %h;
},
hoh => sub {
my $i;
my $order;
my %h = map {
$_ => { data => $i++, order => $order++ }
} @keys;
return join ", ", sort { $h{$a}{order} <=> $h{$b}{order} }
keys %h;
},
hoh_pis => sub {
my $i;
my $order;
my %h = map {
$_ => { data => $i++, order => $order++ }
} @keys;
return join ", ", perfect_insert_sort \%h;
},
IxHash => sub {
my $i;
tie my %h, "Tie::IxHash";
%h = map { $_ => $i++ } @keys;
return join ", ", keys %h;
},
Indexed => sub {
my $i;
tie my %h, "Tie::Hash::Indexed";
%h = map { $_ => $i++ } @keys;
return join ", ", keys %h;
},
IxHashOO => sub {
my $i;
my $o = tie my %h, "Tie::IxHash",
map { $_ => $i++ } @keys;
return join ", ", $o->Keys;
},
IndexedOO => sub {
my $i;
my $o = tie my %h, "Tie::Hash::Indexed",
map { $_ => $i++ } @keys;
my @k = my $k = $o->FIRSTKEY;
while ($k = $o->NEXTKEY($k)) {
push @k, $k;
}
return join ", ", @k;
},
HashOrdered => sub {
my $i;
my $oh = Hash::Ordered->new( map { $_ => $i++ } @keys );
return join ", ", $oh->keys;
},
);
for my $sub (keys %subs) {
print "$sub: ", $subs{$sub}(), "\n";
}
@keys = 1 .. 1_000;
Benchmark::cmpthese -2, \%subs;
这篇关于基于插入顺序对散列进行迭代？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
