迭代Perl数组最有效的方法是什么？

我正在读一个有序的文件，我必须按小时、分钟或秒数数。如果需要，我必须打印出现次数为0的时间（标准化输出）或跳过它们（非标准化输出）。输出显然必须有序

我首先想到的是使用数组。当输出为非标准化时，我大致相当于：

@array[10] = 100;
@array[10000] = 10000;

并打印结果：

foreach (@array) {
  print if defined;
}

有没有办法将迭代次数减少到仅在数组中定义的元素？在前面的示例中，这意味着只进行两次迭代，而不是像使用

$#array

所暗示的那样进行10000次迭代。然后我还需要知道循环中当前数组索引的方法。这样的事情存在吗

我越来越想用散列来代替。使用散列解决了我的问题，也消除了将hh:mm:ss时间转换为索引的需要，反之亦然

---

或者对于这个简单的问题，您有更好的解决方案吗？

是的，使用散列。如果密钥排序正确，则可以迭代哈希的有序密钥数组。

是，使用哈希。如果密钥排序正确，您可以在哈希的密钥有序数组中进行迭代。

您还可以只记住数组中的数字对：

#!/usr/bin/perl
use warnings;
use strict;

my @ar = ( [  10, 100 ],
           [ 100,  99 ],
           [  12,   1 ],
           [  13,   2 ],
           [  15,   1 ],
         );

sub normalized {
    my @ar = sort { $a->[0] <=> $b->[0] } @_;
    map "@$_", @ar;
}

sub non_normalized {
    my @ar = sort { $a->[0] <=> $b->[0] } @_;
    unshift @ar, [0, 0] unless $ar[0][0] == 0;
    my @return;
    for my $i (0 .. $#ar) {
        push @return, "@{ $ar[$i] }";
        push @return, $_ . $" . 0 for 1 + $ar[$i][0] .. $ar[$i + 1][0] - 1;
    }
    return @return;
}


print join "\n", normalized(@ar), q();
print "\n";
print join "\n", non_normalized(@ar), q();

#/usr/bin/perl
使用警告；
严格使用；
my@ar=（[10100]，
[ 100,  99 ],
[  12,   1 ],
[  13,   2 ],
[  15,   1 ],
);
次规范化{
my@ar=sort{$a->[0]$b->[0]}；
地图“@$\”、@ar；
}
次非标准化{
my@ar=sort{$a->[0]$b->[0]}；
除非$ar[0][0]==0，否则@ar[0,0]不移位；
我的回归；
对于我的$i（0..$#ar）{
按@return，“@{$ar[$i]}”；
按@return，$\.$.”.0表示1+$ar[$i][0].$ar[$i+1][0]-1；
}
return@return；
}
打印连接“\n”，标准化（@ar），q（）；
打印“\n”；
打印连接“\n”，非规范化（@ar），q（）；

您还可以只记住数组中的数字对：

#!/usr/bin/perl
use warnings;
use strict;

my @ar = ( [  10, 100 ],
           [ 100,  99 ],
           [  12,   1 ],
           [  13,   2 ],
           [  15,   1 ],
         );

sub normalized {
    my @ar = sort { $a->[0] <=> $b->[0] } @_;
    map "@$_", @ar;
}

sub non_normalized {
    my @ar = sort { $a->[0] <=> $b->[0] } @_;
    unshift @ar, [0, 0] unless $ar[0][0] == 0;
    my @return;
    for my $i (0 .. $#ar) {
        push @return, "@{ $ar[$i] }";
        push @return, $_ . $" . 0 for 1 + $ar[$i][0] .. $ar[$i + 1][0] - 1;
    }
    return @return;
}


print join "\n", normalized(@ar), q();
print "\n";
print join "\n", non_normalized(@ar), q();

！/usr/bin/perl
使用警告；
严格使用；
my@ar=（[10100]，
[ 100,  99 ],
[  12,   1 ],
[  13,   2 ],
[  15,   1 ],
);
次规范化{
my@ar=sort{$a->[0]$b->[0]}；
地图“@$\”、@ar；
}
次非标准化{
my@ar=sort{$a->[0]$b->[0]}；
除非$ar[0][0]==0，否则@ar[0,0]不移位；
我的回归；
对于我的$i（0..$#ar）{
按@return，“@{$ar[$i]}”；
按@return，$\.$.”.0表示1+$ar[$i][0].$ar[$i+1][0]-1；
}
return@return；
}
打印连接“\n”，标准化（@ar），q（）；
打印“\n”；
打印连接“\n”，非规范化（@ar），q（）；

在这种情况下，哈希确实是您需要的。当“键”或“索引”范围相对于有意义元素的数量（即稀疏结构）相对较大时，哈希更适合。如果有意义元素的数量相对于索引范围（密集结构）而言较高，而计算索引的成本较低，那么数组可以更高效，因为它避免了散列算法的开销。我认为，问题是，首先为什么要使用数组？索引是数据的一部分吗？如果没有，为什么还要麻烦他们？@TLP:index就是时间。它是数据的一部分。我的建议是使用散列或二维数组。例如，

push@array[10100]

。保留空数组元素毫无意义。在这种情况下，哈希确实是您需要的。当“键”或“索引”范围与有意义元素的数量（即稀疏结构）相比相对较大时，哈希更适合。如果有意义元素的数量相对于索引范围（密集结构）而言较高，而计算索引的成本较低，那么数组可以更高效，因为它避免了散列算法的开销。我认为，问题是，首先为什么要使用数组？索引是数据的一部分吗？如果没有，为什么还要麻烦他们？@TLP:index就是时间。它是数据的一部分。我的建议是使用散列或二维数组。例如，

push@array[10100]

。保留空数组元素没有意义。我决定使用数组解决问题。散列的优势并不明显，因为我的数据通常在一天中分布得很好。特别是在每小时生成统计数据时。使用散列，我不需要对键进行排序，因为它们表示时间值。我只需要在一段时间内迭代并打印相应的哈希值。散列将根据情况节省一些内存。也许它也会更快（对于这个问题），但我必须进行测试。你的数据是规则间隔的还是不规则的？如果它是不规则的，你将结束与浪费空间的差距；您需要的“此期间0个事件”的粒度越大，您将拥有的空间就越多。如果你给出几个真实的例子，也许会更清楚。我决定用数组来解决这个问题。散列的优势并不明显，因为我的数据通常在一天中分布得很好。特别是在每小时生成统计数据时。使用散列，我不需要对键进行排序，因为它们表示时间值。我只需要在一段时间内迭代并打印相应的哈希值。散列将根据情况节省一些内存。也许它也会更快（对于这个问题），但我必须进行测试。你的数据是规则间隔的还是不规则的？如果它是不规则的，你将结束与浪费空间的差距；您需要的“此期间0个事件”的粒度越大，您将拥有的空间就越多。如果你举几个真实的例子，也许会更清楚。