You could also use a Schwartzian Transform-like approach, in which you massage your data into a list of first-level,second-level key pairs, which you then sort by index [1] (the second-level key). This also allows to have multiple second-level entries per first-level key.  The first-level key is available in [0], so you can easily reconstruct all data for output:

#!/usr/bin/perl

use strict;
use warnings;

my %sorthash;

$sorthash{10}{20} = 3;
$sorthash{10}{40} = 1;
$sorthash{40}{50} = 4;
$sorthash{20}{30} = 2;

print 
  map { "keys: $_->[0]\t$_->[1]\tvalues: $sorthash{$_->[0]}{$_->[1]}\n
+" }
  sort { $a->[1] <=> $b->[1] }
  map { my $key=$_; map { [$key, $_] } keys %{$sorthash{$key}} }
  keys %sorthash;

__END__
keys: 10    20    values: 3
keys: 20    30    values: 2
keys: 10    40    values: 1
keys: 40    50    values: 4
[download]

Update: note that the approach can in principle be extended to more than two levels. Just create the appropriate [$key1, $key2, $key3, ...] entries (think of spreadsheet-like rows) and sort by whatever column you want.

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

my %sorthash = ();

$sorthash{'10'}{'20'}= '1';
$sorthash{'40'}{'50'}= '4';
$sorthash{'20'}{'30'}= '2';

# Invert the hash
my %reverse_hash = ();
for my $keys1 (keys %sorthash ) {
    my $child_hashref = $sorthash{$keys1};
    for my $keys2 (keys %$child_hashref ) {
        $reverse_hash{$keys2}{$keys1} = $child_hashref->{$keys2};
    }
}
# Print after sorting keys
for my $keys2 (sort {$a <=> $b} keys %reverse_hash) {
    my $child_hashref = $reverse_hash{$keys2};
    for my $keys1 (sort {$a <=> $b} keys %$child_hashref) {
        print "keys: $keys1\t$keys2\t";
        print "values: $child_hashref->{$keys1}\n";
    }
}
[download]

Some side notes:

1. Note that the default sort sorts alphabetically not numerically - I noted all your keys were numbers, so I changed the sort.
2. -w and use warnings; are (nearly) redundant. In general, pick one. * w*, warnings, perllexwarn
3. Given how you were using %test, it would be reasonable to scope it to the loop rather that at the script level. Scoping can give you good control over bugs and makes variable intent more clear to maintenance folks.
4. If a hash key contains no spaces, it will be automatically stringified - that means the quotes in your assignments are unnnecessary.

Simply I tried this and seems to be working:-

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

my ($sorthash);
$sorthash->{'10'}->{'20'}= '1';
$sorthash->{'40'}->{'50'}= '4';
$sorthash->{'20'}->{'30'}= '2';


foreach my $diff (sort {$sorthash->{$b} <=> $sorthash->{$a}} keys %{$s
+orthash}) {
    foreach my $rptNo (keys %{$sorthash->{$diff}}) {
        print "$diff--- $rptNo\n";

    }
}
[download]

By: Kuldip Singh Behal

#! /usr/bin/perl

use strict;
use warnings;

my %h;

# if your data is really numerical then the apostrophes are superfluou
+s
$h{10}{20} = 5;
$h{10}{25} = 4;
$h{05}{50} = 3;
$h{20}{30} = 2;

my @temp;

for my $key1 ( keys %h ) {
  for my $key2 ( keys %{ $h{$key1} } ) {
    # create a 3-column table from your hash
    push @temp, [ $key1, $key2, $h{$key1}{$key2} ];
  }
}

# sort it by the second column numerically
for ( sort { $a->[1] <=> $b->[1] } @temp ) {
  print 'key1=', $_->[0], ', key2=', $_->[1], ', value=', $_->[2], "\n
+";
}
[download]

update: a little clarification: By using the solution above you need to store every one of your key1, key2 and value at least once more, but in the terms of memory consumption this can be more than a duplicate.

Thanks for all of the replies. I thought the answer may be along the lines of what all of you are saying. My actual problem is quite a bit more complex than this but the answers to this simple question tells me there is no easy way to accomplish what I am trying to do. I actually have a hohref, hr, that is 5 layers deep. I am trying to sort the entire hr on the keys of layer 4 first and layer 3 second. Since the hr is linear, I am stepping through the entire hash recording each set of keys in an array. I then bubble sort the keys keeping track of each relationship and Voila I have the output for which I was looking. Is there a better way to do this?

While it does increase your complexity, I fail to see why hash flattening or restructuring will not accomplish your goal - the solutions presented here are certainly applicable to your scenario:

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

my %sorthash = ();

$sorthash{'10'}{'20'}{1}{2}{3}= '1';
$sorthash{'40'}{'50'}{1}{4}{3}= '4';
$sorthash{'20'}{'30'}{3}{4}{3}= '2';

# Flatten
my @flat_array = ();
for my $key1 (keys %sorthash) {
    for my $key2 (keys %{$sorthash{$key1}} ) {
        for my $key3 (keys %{$sorthash{$key1}{$key2}} ) {
            for my $key4 (keys %{$sorthash{$key1}{$key2}{$key3}} ) {
                for my $key5 (keys %{$sorthash{$key1}{$key2}{$key3}{$k
+ey4}} ) {
                    push @flat_array, [$key1, $key2, $key3, $key4, $ke
+y5, $sorthash{$key1}{$key2}{$key3}{$key4}{$key5}];
                }
            }
        }
    }
}

# Sort flat array
for my $entry (sort { $a->[3] <=> $b->[3] or $a->[2] <=> $b->[2] } @fl
+at_array)
 {
    print join ", ", @$entry;
    print "\n";
}
[download]

If that's getting a little deep in terms of nested loops, you can write a recursive crawler to flatten the list:

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

my %sorthash = ();

$sorthash{'10'}{'20'}{1}{2}{3}= '1';
$sorthash{'40'}{'50'}{1}{4}{3}= '4';
$sorthash{'20'}{'30'}{3}{4}{3}= '2';

# Flatten
my @flat_array = hash_crawler(\%sorthash);

# Sort flat array
for my $entry (sort { $a->[3] <=> $b->[3] or $a->[2] <=> $b->[2] } @fl
+at_array)
 {
    print join ", ", @$entry;
    print "\n";
}

sub hash_crawler {
    my ($value, @prefix_array) = @_;
    my @results = ();
    if (ref $value) {
        for (keys %$value) {
            push @results, hash_crawler($value->{$_},@prefix_array,$_)
+;
        }
    } else {
        push @results, [@prefix_array, $value];
    }
    return @results;
}
[download]

Update: Fixed bug as per rubasov's post below.

It's not totally clear for me what does it mean "trying to sort the entire hr on the keys of layer 4 first and layer 3 second", but if it means to sort by the 4th column as the key and 3rd column as a subkey, then probably you wanted to write this to sort the flattened array:

sort { $a->[3] <=> $b->[3] or $a->[2] <=> $b->[2] } @flat_array
[download]