So use Benchmark and Devel::Size (or similar modules) to find out what's best for you.

(Update: with cmp you compare with string semantics, are you sure you want that?)

Solution 1 requires only an iterator to keep track of where you are in the hash. You will visit each entry once, and once only.

Solution 2 requires sorting the list, so at a minimum you are going to visit each entry anyway, and the sort algorithm that takes O(n) time in the general case has yet to be invented. This will take more time, no matter what, and worse, it may potentially all for naught if there are no files that are larger than your limit.

The only sane approach is solution 1.

and the sort algorithm that takes O(n) time in the general case has yet to be invented

Well, but for this particular case, sorting numbers, it has already been invented!, it is called radix sort and there are at least two Perl implementations available from CPAN: Sort::Radix (pure perl) and Sort::Key::Radix (XS).

The whole point is that you don't need to sort! It's a net loss whichever way you cut it.

• another intruder with the mooring in the heart of the Perl

In Perl, "break" is called last. But it doesn't seem like you'd want to break out of your foreach loop.

If you were sorting without a custom comparison block, the sort solution could be faster for small data sets, but as this is not the case... and anyway, you can grep:

for my $file (grep { $hash{$_}{Size} > $sizeLimit } @path) {
  delete_file($file);
}
[download]

(untested)

#my @files2del = map { ($hash{$_}->{Size} > $sizelimit ? $_ : () } key
+s %hash;
my @files2del = grep { $hash{$_}->{Size} > $sizelimit } keys %hash;
delete @hash{@files2del};  # deletes paths from hash
unlink @files2del;         # deletes files from disc
[download]

Update: Like salsa wrote (while I wrote my post): the use of grep instead of map is better in this case. See perlfunc for both.
Update 2: Thanks moritz, I always appreciate all feedback. In this case you were just replying faster than I was updating. :-)

my @files2del = map { ($hash{$_}->{Size} > $sizelimit ? $_ : () } keys
+ %hash;
[download]

The perlish way to write such a map involves grep ;-) my @files2del = grep { ($hash{$_}->{Size} > $sizelimit  } keys %hash;

$ perldoc -f break
No documentation for perl function `break' found

$ perldoc -q break
No documentation for perl FAQ keyword `break' found
[download]