A solution using a Schwartzian Transform.

knoppix@Knoppix:~$ perl -le '
@arr = qw{ ch1 ch11 ch2 ch5 ch55 ch16 };
print for
   map  { $_->[ 0 ] }
   sort { $a->[ 1 ] <=> $b->[ 1 ] }
   map  { [ $_, ( split m{(?<=\D)(?=\d)} )[ 1 ] ] }
   @arr;'
ch1
ch2
ch5
ch11
ch16
ch55
knoppix@Knoppix:~$
[download]

I hope this is of interest.

Sort::Key::Natural seems the best way here, so I'd stick with moritz's suggestion.

But if you want to experiment with sort, it can be done with a custom sort subroutine. An example (tested):

#!/usr/bin/perl -w
use strict;

sub by_the_number_at_the_end {
    $a =~ /(\d+)$/;
    my $end_of_a = $1;
    $b =~ /(\d+)$/;
    my $end_of_b = $1;
    return -1 if $end_of_a < $end_of_b;
    return 0  if $end_of_a == $end_of_b;
    return 1  if $end_of_a > $end_of_b;
}

my @array=("ch1","ch11","ch2","ch5","ch55","ch16");

print join ("\n", sort by_the_number_at_the_end @array);
[download]

Regards,
Luke

Sort::Key::Natural will do the trick assuming you can use CPAN (see Yes, even you can use CPAN for tips on how), but there are a couple concepts here that are probably worth learning in any case:

use strict;
use warnings;

my @aChapters=("ch1","ch11","ch2","ch5","ch55","ch16");
my @aSorted = sort {
  my ($sA, $iA) = ($a =~ /(^[^\d]+)(\d+)/);
  my ($sB, $iB) = ($b =~ /(^[^\d]+)(\d+)/);
  my $x = $sA cmp $sB;
  ($x = $iA <=> $iB) unless $x;
  $x;
} @aChapters;

local $"="\n";
print "@aSorted";
[download]

$a and $b are special variables that represent the two members of the list you want to sort. The main trick here is to (i) split your name into two parts: an alpha part and a numeric part (ii) compare the alpha part using the alpha comparison operator (cmp) and the numeric part using the numeric comparison operator (<=>). See perlop for more information.

Best, beth

my @sorted = sort { substr($a,2) <=> substr($b,2) } @array;
[download]

@array = map {substr($_,2)} @array;
my @sorted = sort { $a <=> $b } @array;
@sorted = map { "ch$_" } @sorted;
[download]

map {"ch$_"} sort {$a <=> $b} map {/(\d+)/} @array
[download]

# first num
sub num_from_str {
    my $str = shift;
    my ($num) = $str =~ /(\d+)/;
    return $num;
}
my @a = qw( ch1 ch11 ch55 ch5 ch2 ch16 );
my @sorted = sort { num_from_str($a) <=> num_from_str($b) } @a;
print "$_\n" for @sorted;
[download]

update: ... but Sort::Key::Natural is a more complete solution, because it sorts based on the alphabetical bits as well.

map {'ch'.(0+$_)} sort map {sprintf "%.10u", /(\d+)/} @array;
[download]

just for the sake of using a technique of Advanced Sorting - GRT - Guttman Rosler Transform, i.e. make a map sort map but with a bare/string sort.

Of course, a pack 'N' would be preferable over the sprintf.