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

use Data::Dumper;

my @a = (1, 1, 2, 3, 4, 4, 8, 8);
my @b = (3, 4, 3, 5, 6, 7, 9, 10);

print Dumper related(\@a, \@b);

sub related {
    my @a = @{ +shift };
    my @b = @{ +shift };
    die "Different length.\n" if @a != @b;

    my %r;
    PAIR: for my $i (0 .. $#a) {
        my @classes;
        for my $e ($a[$i], $b[$i]) {
            push @classes, $r{$e} if exists $r{$e};
        }

        # Both numbers already classified. Merge their classes if diff
+erent.
        if (@classes == 2) {
            next PAIR if $classes[0] == $classes[1];
            my ($min, $max) = sort { $a <=> $b } @r{$a[$i], $b[$i]};
            $r{$_} = $min for grep $r{$_} == $max, keys %r;

        # Just one number already classified. Classify the second one 
+to the same class.
        } elsif (@classes == 1) {
            if (exists $r{$a[$i]}) {
                $r{$b[$i]} = $r{$a[$i]};
            } else {
                $r{$a[$i]} = $r{$b[$i]};
            }

        # Both numbers are seen for the first time.
        } else { # @classes == 0
            my $min = $a[$i] < $b[$i] ? $a[$i] : $b[$i];
            @r{$a[$i], $b[$i]} = ($min) x 2;
        }
    }
    return \%r;
}
[download]

This is an interesting problem. choroba’s excellent solution can be simplified somewhat by using the Set::Scalar module:

#! perl
use strict;
use warnings;
use Set::Scalar;

my @a = (1, 1, 2, 3, 4, 4, 8,  8);
my @b = (3, 4, 3, 5, 6, 7, 9, 10);
my @sets;
@a == @b or die "The arrays are of different lengths.\n";

for (0 .. $#a)
{
    my ($ai, $bi, $found) = ($a[$_], $b[$_], 0);

    for (@sets)
    {
        if ($_->has($ai) || $_->has($bi))
        {
            $found = 1;
            $_->insert($ai, $bi);
            last;
        }
    }

    push @sets, Set::Scalar->new($ai, $bi) unless $found;
}

OUTER: for my $i (reverse 1 .. $#sets)
{
    for my $j (reverse 0 .. $i - 1)
    {
        unless ($sets[$i]->intersection($sets[$j])->is_empty())
        {
            $sets[$j] = $sets[$j]->union($sets[$i]);
            splice(@sets, $i, 1);
            redo OUTER;
        }
    }
}

print "$_\n" for @sets;
[download]

Update: Added block labelled OUTER to merge sets having common elements.

Output:

14:35 >perl 366_SoPW.pl
(1 2 3 4 5 6 7)
(10 8 9)

14:36 >
[download]

Hope that helps,

This clearly can be viewed as a problem in graph theory. There is a good chance a solution can be found on CPAN. Even if you fail to find such module, the time spent looking is probably not wasted because you will learn standard terminology and learn not to wast time on promising approaches that do not work.

Node how to find combine common elements of an array? gives a few solutions to this problem. Your input set to those solutions would be a set of doubletons, each represented as a string of whitespace delimited elements, i.e., "$a[i] $b[i]".

I can go from the number in either array,or start with any element in any of the two arrays.Thank you all for considering my question.I will try today.I tried to write a for loop based on index and value but its not working as expected.

Hello.

With hash of hash, for looking ups.

#!/usr/bin/perl
use strict; use warnings; use Data::Dumper; 
my @a=(1,1,2,3,4,4,8,8);  
my @b=(3,4,3,5,6,7,9,10);
my $hoh={};

for ( 0 .. $#a){
    $hoh->{$a[$_]}->{$b[$_]}++;
    $hoh->{$b[$_]}->{$a[$_]}++;
}
sub recursive {
    my ($hoh, $key, $path, @vals) =@_;
    for ( grep { $_ ne $key } @vals){
        next if exists($path->{$_});
        $hoh->{$key}->{$_}++;
        $path->{$_}++;
        recursive($hoh, $key, $path, keys %{$hoh->{$_}} );
    }
}
for (sort {$a <=> $b}keys %$hoh){
    recursive($hoh, $_, {}, keys %{$hoh->{$_}} );   
}

#print Dumper $hoh;
for (sort {$a <=> $b}keys %$hoh){
    print "$_=" , join(",", keys %{$hoh->{$_}}), "\n";
}

__DATA__
this prints ...
1=6,4,3,7,2,5
2=6,4,1,3,7,5
3=6,4,1,7,2,5
4=6,1,3,7,2,5
5=6,1,4,3,7,2
6=1,4,3,7,2,5
7=6,1,4,3,2,5
8=10,9
9=8,10
10=8,9
[download]

#!/usr/bin/perl
#with graph
use strict; use warnings; use Data::Dumper;
use Graph;
my $g =Graph::Undirected->new;

my @a=(1,1,2,3,4,4,8,8);
my @b=(3,4,3,5,6,7,9,10); 
    
for ( 0 .. $#a){
    $g->add_edge($a[$_], $b[$_]);
}   
print Dumper $g->connected_components;
__DATA__
this prints ...$VAR1 = [
          9,
          8,
          10
        ];
$VAR2 = [
          6,
          4,
          1,
          3,
          2,
          5,
          7
        ];
[download]