The first and foremost reason your script is failing is that you are never putting anything into @missing except undefined values. $commseq is never defined nor declared. There are also at least four other undeclared variables in your script @sortlst, @missing, $nextseq, $curseq. I'm guessing therefore you are not using strictures.

It is very important that you include the following two lines at the start of every script and module:

use strict;
use warnings;
[download]

These two lines will save you a world of trouble by quickly drawing your attention to potential bugs and problems. Had you done that, it would have been immediately clear to you that $commseq was undefined.

I also note that you are using ne to compare numbers. Even though the numbers originally began a strings, Perl can happily convert those strings to numbers. If you want to compare two numbers as numbers (and I assume you do since your sort routine uses <=> ), you should use the numeric operators:  < <= == => > - see perlop for more information.

As for the algorithm itself, if you have large gaps you will be printing out lists of numbers that will be so long as to be unusable. If you want to print out all the missing numbers (not just the places where only one is missing), then you might want to consider modifying your code to print out ranges of missing numbers rather than each number individually, like this:

#    if ($curseq ne $nextseq) {
#      while ($curseq ne $nextseq) {
#       push(@missing, $commseq);
#        print ("Found missing file sequence $curseq - $nextseq\n");
#        $curseq++;
#      }
#    }
#    $curseq = $nextseq;
#  }

    if ($curseq < $nextseq) {
      my $endseq = $nextseq-1;
      if ($curseq == $endseq) {
        push @missing, $curseq;
      } else {
        push @missing, "$curseq-$endseq";
      }
    }
    $curseq = $nextseq;
  }
  print "missing=<@missing>\n";
[download]

Best, beth

Update added observations other than strictures

If I understand what you're asking, you want to detect gaps in the sequence if you've only skipped one number; you don't care about gaps of 2 or more, like the one between 0005 and 9996.

So for each number you know exists (call it 'n'), if n+2 (with "wraparound" after 9999 back to 0001) exists but n+1 does not, that's a "skip":

my @skips = get_skips(qw(9996 9998 9999 0001 0003 0005));

print join(',', sort @skips) . "\n"; # 0002,0004,9997

sub next_seq {
    my $n = shift() + 1;
    if ($n > 9999) {
        $n = 1;
    }
    return sprintf '%04d', $n;
}

sub get_skips {
    my %s = map { $_, 1 } @_;
    my @r;
    for (keys %s) {
        my $next = next_seq($_);
        my $nextnext = next_seq($next);
        if (exists($s{$nextnext}) && ! exists($s{$next})) {
            push @r, $next;
        }
    }
    return @r;
}
[download]

I'll leave extracting the list of numbers from the filenames to you.

If you can use modules you might like the following solution:

#!/usr/local/bin/perl
#
use strict;
use warnings;
use Set::IntSpan::Fast;

my @sequence_numbers = map {int($_)} (<DATA>);

my $set = Set::IntSpan::Fast->new();
$set->add_range(1,9999);
$set->invert();
$set->add(@sequence_numbers);
$set->invert();
print $set->as_string() . "\n";

__DATA__
9996 
9998 
9999 
0001 
0003 
0005
[download]

Which produces:

2,4,6-9995,9997
[download]