I know that I could probably use a hash instead, but don't want to use a hash

The only time a hash is not acceptible for something like this, is when you want to maintain the original insertion order. If you don't, then follow tlm's advice and use that.

If, however, you need to maintain the original order, the easiest solution is to use both a hash and an array. You may be thinking, "this sounds like a real pain." But it's not. Here's a demonstration:

my %mountpoints;
my @mountpoints;

for (qw(foo bar bar foo baz)) {
    push @mountpoints, $_ unless $mountpoints{$_}++;
}
[download]

If you need to keep the original order, is there any overhead to using Tie:LLHash over using the array? I'm guessing that Tie::LLHash must be using an array, but just provides an interface to work with only the hash?

is there any overhead to using Tie:LLHash over using the array?

It depends on what you mean by "overhead". Certainly, there's overhead involved in loading a module. There's overhead involved in installing a module. Depending on how the module is implemented, there's likely overhead involved in using the module. Whether that overhead is worth it or not depends on a lot of factors. But personally, I would stick with a plain dual hash/array approach unless there was a specific reason not to.

Hashes are your friends! Perl programs often use them for precisely what you want to do. Just do this

$mounts{ "$directory/$entry" }++;
[download]

$mounts{ "$directory/$entry" } = 1;
[download]

my @mounts = keys %mounts;
[download]

Incidently, if you really don't want to use a hash you will be able to do the following in Perl6 which is hiding the search under the covers.

push @array, $value if $value eq none( @array );
[download]

my %hash;
for (qw(first second first third second fourth)) {
    exists $hash{$_} or $hash{$_} = keys %hash;  # Put stuff in like t
+his
}
print "$_\n" for sort {$hash{$a} <=> $hash{$b}} keys %hash; # Get stuf
+f out like this
[download]

I would write it like this:

$filename = "$directory/$entry";
if( myExists( $filename, @mounts ) == 0 ){
   push(@mounts, $filename);
}

sub myExists(){
   my $compare = shift;

   foreach my $element (@_){
      if( $element eq $compare ){
         return 1;
      }
   }
   
   return 0;
}
[download]

I know that this is more code than some of the previous solutions, but it has advantages. It is more readable and can allow you to more precisely define what it means to exist. Say for instance that you wanted to only add it if it were unique in the first 256 charachters, or alter it otherwise, this would be easy to do. In addition, it is also more resource friendly and less confusing than maintaining both arrays and hashes.

Good luck

The problem is that you have to search the whole array every time you insert, making insertion an O(N) operation. With a hash, the lookup is essentially constant-time. Building an array becomes O(N^2), like bubblesort (which is also easy to read an understand, and which nobody uses).

You can use a hash in all the same ways of defining existence. If you only want unique in the first 256 chars, only hash those.

---

Caution: Contents may have been coded under pressure.

It also does a full linear search of the entire list of items (which has to be copied onto the stack for each myExists call) if the element isn't already present. Replacing an O(N)-ish exists $seen{$key} with something exponential doesn't sound like it's worth any supposed simplification.

Not wanting to use a hash for keeping track of set membership in Perl is in the same vein as people who want to do iterative-task-foo without using foreach or map. Learning the idioms will make your life much easier.