Having looked over your code, I think I found your problem, and I have a few other comments.

The only substantial change I made was the assignment to @nodevalues in the cpt sub. It now reads:

    my @nodevalues= map { [ @{$_} ] } @{$_[2]};
[download]

The reason why that helps is that $_[2] is a reference to an array containing other array references. What my change does is copy the arrays in the main array instead of copying the references. This is important because further down in your code, you do "shift @{$temparray[$i]};", which modifies one of those arrays. Without my modification, here is what happens. Before the first call to cpt, this is what $values looks like:

$VAR1 = [
          [
            'sprinkler',
            't',
            'f'
          ],
          [
            'cloudy',
            't',
            'f'
          ],
          [
            'rain',
            't',
            'f'
          ],
          [
            'wetgrass',
            't',
            'f'
          ]
        ];
[download]

After the first call to cpt, it looks like this:

$VAR1 = [
          [
            't',
            'f'
          ],
          [
            't',
            'f'
          ],
          [
            'rain',
            't',
            'f'
          ],
          [
            'wetgrass',
            't',
            'f'
          ]
        ];
[download]

Notice that the first two arrays have been modified. The above is the output of Data::Dumper, by the way. It's a pretty good way of visualizing your data structures.

The fix I've shown will help this particular problem, but it would not have helped if the data structure involved were another level deep. For a more general solution to this kind of problem have a look at merlyn's column Deep copying, not Deep secrets.

My other comments, briefly:

• I'm not sure why you'd be using glob.
• This code at the end of cpt is not necessary (and not executed):

      $node="";
      @parents=(); 
      @nodevalues=();
      %hash=();
      @nodeindex=();
      @temparray=();
      $string="";
      @temp=();
      $s="";
  [download]

  Because those are all lexical variables, they get new values every time cpt is called.

• In general, things like for (my $j=0;$j<=$#nodevalues;$j++) ought to be more like foreach my $nv ( @nodevalues ).
• You might want to look at some of CPAN's graph modules.

    return {%hash}; 
    
    $node="";
    @parents=(); 
    @nodevalues=();
    %hash=();
    @nodeindex=();
    @temparray=();
    $string="";
    @temp=();
    $s="";
}
[download]

Are you aware that the effect of a return statement is immediate?
All those assignments after the return, above, don't get executed.

This section of your code

my $couldy=['cloudy','t','f']; # 'cloudy' is the node name and 't','f'
+ are the values this node can assume. Likewise for other nodes.
my $sprinkler=['sprinkler','t','f'];
my $rain=['rain','t','f'];
my $wetgrass=['wetgrass','t','f'];
my $values=[$sprinkler,$couldy,$rain,$wetgrass];
[download]

Could be re-written without the intermediate variables as you don't seem to use them again.

my $raValueSets =
   [
      ['cloudy', 't', 'f'],
      ['sprinkler', 't', 'f'],
      ['rain', 't', 'f'],
      ['wetgrass', 't', 'f'],
   ];
[download]

Passing arguments to sub cpt { ... }, I would tend to keep the anonymous arrays as they are and de-reference them later, like this

sub cpt
{
    my ($node, $raParents, $raNodeValues) = @_;
    ...
    foreach my $i ( @$raParents )
    {
        for my $j ( 0 .. $#$raNodeValues )
        {
            if ( $i eq $raNodeValues->[$j]->[0] )
            {
                push @nodeindex, $j; 
            }
        }
    }
    ...
}
[download]

Note that I use the -> de-reference operator rather than the ${$x}[n] notation, which can quickly become unreadable. In sub parentchildrelationship { ... } you do my $node=$_[0]; #or use "shift" but you can also do

    my ($node) = @_;
[download]

which puts the LHS in list context and assigns the first element of @_ to the first element of that list, namely $node. Actually, I tend to use shift.

I hope these points are of interest.

Cheers,

JohnGG

• A visual representation of a simple example
• The desired output for that example

I know this must be frustrating for you but, in my opinion, you still coming up short. For instance, here is one way you may have provided a visual representation of your network (which really isn't a tree):

While you did provide the desired output, there is no explanation as to what it means. For instance, I would have probably labeled the output much better:

You likely have a relatively simple mistake as indicated by the other replies in this node but that isn't easy for me to see. In fact, when I run your code I do not even get the output you claim it produces (array refs stringified in quotes).

Your description of your problem does not make your intended results clear and your code is also not easy to digest. I could take the time to disect your problem and rewrite your code but that is what you should have done.